feat(settings): add anonymous analytics opt-out

apps/mobile/src/components/AppSymbol.tsx

@@ -144,6 +144,7 @@ const ANDROID_ICON_BY_SF_SYMBOL = {
   "bolt.horizontal.circle": IconBolt,
   brain: IconBrain,
   camera: IconCamera,
+  "chart.bar": IconChartBar,
   "chart.bar.xaxis": IconChartBar,
   checkmark: IconCheck,
   "checkmark.circle": IconCircleCheck,

apps/mobile/src/features/settings/SettingsServerControlsRouteScreen.tsx

@@ -230,6 +230,27 @@ function ServerSettingsDetail(props: { readonly page: SettingsPage }) {
     (target) =>
       target.environment.serverConfig.environment.capabilities.threadRestartContinuation === true,
   );
+
+  const telemetryOverridden = targets.some(
+    (target) => target.environment.serverConfig.telemetryDisabledByEnvironment === true,
+  );
+
+  const telemetryPartiallyOverridden =
+    telemetryOverridden &&
+    targets.some(
+      (target) => target.environment.serverConfig.telemetryDisabledByEnvironment !== true,
+    );
+
+  const telemetryValue = telemetryPartiallyOverridden
+    ? null
+    : !telemetryOverridden && uniform("telemetryEnabled");
+
+  const telemetryDescription = telemetryPartiallyOverridden
+    ? "Disabled by some selected servers' environment configuration."
+    : telemetryOverridden
+      ? "Disabled by the server's environment configuration."
+      : "Share anonymous usage data to help improve T3 Code.";
+
   const disabledFor = (key: string) =>
     disabled ||
     (projectSelected &&
@@ -449,6 +470,23 @@ function ServerSettingsDetail(props: { readonly page: SettingsPage }) {
                       ))}
                     </SettingsSection>
                   ) : null}
+                  <SettingsSection title="Privacy">
+                    <SettingsSwitchRow
+                      icon="chart.bar"
+                      label="Anonymous analytics"
+                      subtitle={
+                        projectSelected
+                          ? "Environment-wide setting. Select All projects to change it."
+                          : telemetryDescription
+                      }
+                      value={telemetryValue}
+                      mixedValue={false}
+                      disabled={telemetryOverridden || disabledFor("telemetryEnabled")}
+                      onValueChange={(value) => {
+                        write({ telemetryEnabled: value });
+                      }}
+                    />
+                  </SettingsSection>
                   <SettingsSection title="Updates">
                     <SettingsSwitchRow
                       icon="arrow.clockwise"

apps/mobile/src/features/settings/components/SettingsSwitchRow.tsx

@@ -8,9 +8,12 @@ import { SettingsControlRow } from "./SettingsControlRow";
 export function SettingsSwitchRow(
   props: Omit<ComponentProps<typeof SettingsControlRow>, "children"> & {
     readonly value: boolean | null;
+    readonly mixedValue?: boolean;
     readonly onValueChange: (value: boolean) => void;
   },
 ) {
+  const mixedValue = props.mixedValue ?? true;
+  const mixedLabel = mixedValue ? "on" : "off";
   return (
     <SettingsControlRow
       disabled={props.disabled}
@@ -20,13 +23,13 @@ export function SettingsSwitchRow(
     >
       {props.value === null ? (
         <Pressable
-          accessibilityLabel={`Set ${props.label} on for selected environments`}
+          accessibilityLabel={`Set ${props.label} ${mixedLabel} for selected environments`}
           accessibilityRole="button"
           disabled={props.disabled}
           className="rounded-full bg-subtle px-3 py-2 active:opacity-70"
-          onPress={() => props.onValueChange(true)}
+          onPress={() => props.onValueChange(mixedValue)}
         >
-          <Text className="text-sm font-t3-medium text-foreground">Mixed · Set on</Text>
+          <Text className="text-sm font-t3-medium text-foreground">Mixed · Set {mixedLabel}</Text>
         </Pressable>
       ) : (
         <ThemedSwitch

apps/server/src/device/DeviceService.test.ts

@@ -157,6 +157,7 @@ const fixture = Effect.fn("fixture")(function* (
           })),
         streamChanges: Stream.empty,
         subscribeChanges: Effect.succeed(Stream.empty),
+        subscribePersistedChanges: Effect.succeed(Stream.empty),
       }),
     ),
     Effect.provideService(

apps/server/src/orchestration-v2/ThreadSettlementService.test.ts

@@ -575,6 +575,9 @@ const makeHarness = Effect.fn("makeThreadSettlementHarness")(function* (options:
     updateProviderInstance: () => Effect.die("Unexpected provider mutation"),
     withSettingsSnapshot: (use) => Ref.get(settings).pipe(Effect.flatMap(use)),
     streamChanges: Stream.fromPubSub(settingsChanges),
+    subscribePersistedChanges: PubSub.subscribe(settingsChanges).pipe(
+      Effect.map(Stream.fromSubscription),
+    ),
     subscribeChanges: PubSub.subscribe(settingsChanges).pipe(
       Effect.map((subscription) => Stream.fromSubscription(subscription)),
     ),

apps/server/src/provider/ProviderRegistry.test.ts

@@ -359,6 +359,9 @@ function makeMutableServerSettingsService(
       get streamChanges() {
         return Stream.fromPubSub(changes);
       },
+      get subscribePersistedChanges() {
+        return PubSub.subscribe(changes).pipe(Effect.map(Stream.fromSubscription));
+      },
       get subscribeChanges() {
         return PubSub.subscribe(changes).pipe(
           Effect.map((subscription) => Stream.fromSubscription(subscription)),

apps/server/src/provider/makeManagedServerProvider.test.ts

@@ -303,6 +303,9 @@ describe("makeManagedServerProvider", () => {
             updateProviderInstance: () => Effect.die(new Error("unused in this test")),
             withSettingsSnapshot: (use) => Ref.get(serverSettingsRef).pipe(Effect.flatMap(use)),
             streamChanges: Stream.empty,
+            subscribePersistedChanges: PubSub.subscribe(serverSettingsChanges).pipe(
+              Effect.map(Stream.fromSubscription),
+            ),
             subscribeChanges: PubSub.subscribe(serverSettingsChanges).pipe(
               Effect.map((subscription) => Stream.fromSubscription(subscription)),
             ),

apps/server/src/server.ts

@@ -636,7 +636,7 @@ const layerRuntimeDependencies = layerRuntimeCoreDependencies.pipe(
   Layer.provideMerge(layerResourceDiagnostics),
   Layer.provideMerge(layerUsage),
   Layer.provideMerge(TraceDiagnostics.layer),
-  Layer.provideMerge(AnalyticsService.layer),
+  Layer.provideMerge(AnalyticsService.layer.pipe(Layer.provide(layerServerSettings))),
   Layer.provideMerge(ExternalLauncher.layer),
   Layer.provideMerge(RemoteOpenTargets.layer),
   Layer.provideMerge(DirectEndpoints.layer),

apps/server/src/serverSettings.test.ts

@@ -97,6 +97,26 @@ const recordProviderUsage = (provider: string, instanceId: string | null = provi
   });
 
 it.layer(NodeServices.layer)("server settings", (it) => {
+  it.effect("persists the analytics opt-out and allows opting back in", () =>
+    Effect.gen(function* () {
+      const service = yield* ServerSettingsModule.ServerSettingsService;
+      const config = yield* ServerConfig.ServerConfig;
+      const fs = yield* FileSystem.FileSystem;
+      assert.isTrue((yield* service.getSettings).telemetryEnabled);
+
+      for (const telemetryEnabled of [false, true]) {
+        yield* service.updateSettings({ telemetryEnabled });
+
+        const persisted = yield* decodeServerSettingsJson(
+          yield* fs.readFileString(config.settingsPath),
+        );
+
+        assert.equal(persisted.telemetryEnabled, telemetryEnabled);
+        assert.equal((yield* service.getSettings).telemetryEnabled, telemetryEnabled);
+      }
+    }).pipe(Effect.provide(layerServerSettings())),
+  );
+
   it.effect("migrates saved token delivery to paragraph buffering without resetting settings", () =>
     Effect.gen(function* () {
       const config = yield* ServerConfig.ServerConfig;

apps/server/src/serverSettings.ts

@@ -288,6 +288,13 @@ export class ServerSettingsService extends Context.Service<
      * snapshot and a lazily started stream must not be lost.
      */
     readonly subscribeChanges: Effect.Effect<Stream.Stream<ServerSettings>, never, Scope.Scope>;
+
+    /** Subscribe without loading secrets, for settings that must react before secret-store I/O. */
+    readonly subscribePersistedChanges: Effect.Effect<
+      Stream.Stream<ServerSettings>,
+      never,
+      Scope.Scope
+    >;
   }
 >()("t3/serverSettings/ServerSettingsService") {
   /** @deprecated Import and use `layerTest` from this module. */
@@ -309,6 +316,7 @@ const makeTest = (overrides: DeepPartial<ServerSettings> = {}) =>
         : {}),
     });
     const currentSettingsRef = yield* Ref.make<ServerSettings>(initialSettings);
+    const changesPubSub = yield* PubSub.unbounded<ServerSettings>();
     const writeSemaphore = yield* Semaphore.make(1);
     const getSettings = Ref.get(currentSettingsRef).pipe(Effect.map(resolveTextGenerationProvider));
 
@@ -320,6 +328,7 @@ const makeTest = (overrides: DeepPartial<ServerSettings> = {}) =>
           Effect.flatMap(update),
           Effect.flatMap(normalizeServerSettings),
           Effect.tap((nextSettings) => Ref.set(currentSettingsRef, nextSettings)),
+          Effect.tap((nextSettings) => PubSub.publish(changesPubSub, nextSettings)),
           Effect.map(resolveTextGenerationProvider),
         ),
       );
@@ -346,8 +355,11 @@ const makeTest = (overrides: DeepPartial<ServerSettings> = {}) =>
         ),
       withSettingsSnapshot: (use) =>
         writeSemaphore.withPermits(1)(getSettings.pipe(Effect.flatMap(use))),
-      streamChanges: Stream.empty,
-      subscribeChanges: Effect.succeed(Stream.empty),
+      streamChanges: Stream.fromPubSub(changesPubSub),
+      subscribeChanges: PubSub.subscribe(changesPubSub).pipe(Effect.map(Stream.fromSubscription)),
+      subscribePersistedChanges: PubSub.subscribe(changesPubSub).pipe(
+        Effect.map(Stream.fromSubscription),
+      ),
     } satisfies ServerSettingsService["Service"];
   });
 
@@ -1390,6 +1402,9 @@ const make = Effect.gen(function* () {
         Effect.map((subscription) => materializeChanges(Stream.fromSubscription(subscription))),
       );
     },
+    get subscribePersistedChanges() {
+      return PubSub.subscribe(changesPubSub).pipe(Effect.map(Stream.fromSubscription));
+    },
   } satisfies ServerSettingsService["Service"];
 });