From edae409f8e2d3f5ddb4a799bb32f1c53666b6d0b Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Mon, 16 Nov 2026 21:42:24 +0000 Subject: [PATCH 1/5] test(desktop): relay tracing honors a telemetry opt-out from the login shell Fails on main: the relay telemetry flag is computed once when IPC handlers are installed, before the login shell environment is published (#37772). Co-Authored-By: Claude Opus 5.5 --- apps/desktop/src/ipc/methods/window.test.ts | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/apps/desktop/src/ipc/methods/window.test.ts b/apps/desktop/src/ipc/methods/window.test.ts index de202529c4113..144dfb27d5892 100644 --- a/apps/desktop/src/ipc/methods/window.test.ts +++ b/apps/desktop/src/ipc/methods/window.test.ts @@ -235,6 +235,7 @@ describe("installRelayTelemetryEnabled", () => { const relayTelemetryEnabled = ( env: NodeJS.ProcessEnv, policy?: Parameters[0], + loginShellEnv: NodeJS.ProcessEnv = {}, ) => Effect.gen(function* () { const listeners = new Map(); @@ -250,6 +251,8 @@ describe("installRelayTelemetryEnabled", () => { Layer.mergeAll(DesktopIpc.layerTest(ipcMain), DesktopManagedPolicy.layerTest(policy)), ), ); + // The login shell's values land in the process env after startup has installed handlers. + Object.assign(env, loginShellEnv); const event = { returnValue: undefined as unknown }; listeners.get(IpcChannels.GET_RELAY_TELEMETRY_ENABLED_CHANNEL)?.(event as never); return event.returnValue; @@ -259,6 +262,9 @@ describe("installRelayTelemetryEnabled", () => { Effect.gen(function* () { assert.isFalse(yield* relayTelemetryEnabled({ T3CODE_TELEMETRY_ENABLED: "false" })); assert.isTrue(yield* relayTelemetryEnabled({})); + assert.isFalse( + yield* relayTelemetryEnabled({}, undefined, { T3CODE_TELEMETRY_ENABLED: "false" }), + ); }), ); From 18a6ada1dd52f173de3ff4fa8c35792dc4fe8df8 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Mon, 16 Nov 2026 21:47:00 +0000 Subject: [PATCH 2/5] fix(desktop): relay tracing honors a telemetry opt-out from the login shell The relay telemetry flag was computed once when the IPC handlers were installed, before the login shell environment is published, and the shell environment cache did not keep T3CODE_TELEMETRY_ENABLED. Read the environment on each call and cache the variable so later launches have it at startup. Fixes pingdotgg/t3code#37772 Co-Authored-By: Claude Opus 5.5 --- apps/desktop/src/ipc/methods/window.ts | 16 ++++++++-------- .../src/shell/DesktopShellEnvironment.test.ts | 2 ++ .../desktop/src/shell/DesktopShellEnvironment.ts | 1 + 3 files changed, 11 insertions(+), 8 deletions(-) diff --git a/apps/desktop/src/ipc/methods/window.ts b/apps/desktop/src/ipc/methods/window.ts index 38887ec71d906..da5060d6c0c58 100644 --- a/apps/desktop/src/ipc/methods/window.ts +++ b/apps/desktop/src/ipc/methods/window.ts @@ -82,22 +82,22 @@ export const getAppBranding = DesktopIpc.makeSyncIpcMethod({ /** * Relay traces leave the machine, so a policy with `telemetry: false`, or one that cannot be read, - * stops them. Read once here: a sync IPC handler cannot wait on the filesystem. + * stops them. The policy is read once here: a sync IPC handler cannot wait on the filesystem. The + * environment is read per call because the login shell's values are published after install. */ export const installRelayTelemetryEnabled = Effect.fn("desktop.ipc.window.installRelayTelemetry")( function* () { const ipc = yield* DesktopIpc.DesktopIpc; - const enabled = - isRelayTracingEnabled(yield* HostProcess.Environment) && - (yield* (yield* DesktopManagedPolicy.DesktopManagedPolicy).read.pipe( - Effect.map((found) => found?.document.limits?.telemetry !== false), - Effect.orElseSucceed(() => false), - )); + const env = yield* HostProcess.Environment; + const policyAllows = yield* (yield* DesktopManagedPolicy.DesktopManagedPolicy).read.pipe( + Effect.map((found) => found?.document.limits?.telemetry !== false), + Effect.orElseSucceed(() => false), + ); yield* ipc.handleSync( DesktopIpc.makeSyncIpcMethod({ channel: IpcChannels.GET_RELAY_TELEMETRY_ENABLED_CHANNEL, result: Schema.Boolean, - handler: () => Effect.succeed(enabled), + handler: () => Effect.sync(() => policyAllows && isRelayTracingEnabled(env)), }), ); }, diff --git a/apps/desktop/src/shell/DesktopShellEnvironment.test.ts b/apps/desktop/src/shell/DesktopShellEnvironment.test.ts index 7808682dfd82b..13f9bc85be945 100644 --- a/apps/desktop/src/shell/DesktopShellEnvironment.test.ts +++ b/apps/desktop/src/shell/DesktopShellEnvironment.test.ts @@ -355,6 +355,7 @@ describe("DesktopShellEnvironment", () => { NODE_EXTRA_CA_CERTS: "/cached/ca.pem", SSL_CERT_FILE: "/cached/cert.pem", SSL_CERT_DIR: "/cached/certs", + T3CODE_TELEMETRY_ENABLED: "false", SSH_AUTH_SOCK: "/stale.sock", NODE_OPTIONS: "--bad", }, @@ -394,6 +395,7 @@ describe("DesktopShellEnvironment", () => { assert.equal(env.NODE_EXTRA_CA_CERTS, "/launcher/ca.pem"); assert.equal(env.SSL_CERT_FILE, ""); assert.equal(env.SSL_CERT_DIR, "/cached/certs"); + assert.equal(env.T3CODE_TELEMETRY_ENABLED, "false"); assert.equal(env.SSH_AUTH_SOCK, "/current.sock"); assert.isUndefined(env.NODE_OPTIONS); assert.equal(yield* fs.readFileString(cachePath), contents); diff --git a/apps/desktop/src/shell/DesktopShellEnvironment.ts b/apps/desktop/src/shell/DesktopShellEnvironment.ts index f2a92069f066b..0ef7ac2368212 100644 --- a/apps/desktop/src/shell/DesktopShellEnvironment.ts +++ b/apps/desktop/src/shell/DesktopShellEnvironment.ts @@ -651,6 +651,7 @@ const CACHED_ENV_NAMES = [ "SSL_CERT_FILE", "SSL_CERT_DIR", "NODE_EXTRA_CA_CERTS", + "T3CODE_TELEMETRY_ENABLED", ] as const; /** @public */ From f65891140de560fa9a3ddfde319bb6846c0f1753 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Mon, 16 Nov 2026 21:58:06 +0000 Subject: [PATCH 3/5] fix(desktop): keep relay tracing off until the login shell environment is known The renderer reads the relay telemetry flag once, while its runtime module initializes, and builds the relay exporter from that answer. When it asked before shell discovery finished, a T3CODE_TELEMETRY_ENABLED=false exported only in the login profile was not yet in the environment, so tracing stayed on for the session. Answer false until discovery has finished. Co-Authored-By: Claude Opus 5.5 --- apps/desktop/src/app/DesktopApp.test.ts | 1 + .../DesktopBackendConfiguration.test.ts | 1 + apps/desktop/src/ipc/methods/window.test.ts | 22 ++++++++++++++++--- apps/desktop/src/ipc/methods/window.ts | 11 +++++++--- .../src/shell/DesktopShellEnvironment.ts | 3 +++ .../DesktopTelemetryPublisher.test.ts | 1 + 6 files changed, 33 insertions(+), 6 deletions(-) diff --git a/apps/desktop/src/app/DesktopApp.test.ts b/apps/desktop/src/app/DesktopApp.test.ts index aca3b4fc7fe66..ad7d1fb52233b 100644 --- a/apps/desktop/src/app/DesktopApp.test.ts +++ b/apps/desktop/src/app/DesktopApp.test.ts @@ -122,6 +122,7 @@ it.effect.each([false, true])( installIntoProcess: Effect.succeed(true), awaitDiscovery: Effect.succeed(true), awaitUserShellDiscovery: Effect.succeed(true), + discoveryFinished: Effect.succeed(true), updates: Stream.empty, }), Effect.provideService(DesktopAppSettings.DesktopAppSettings, { diff --git a/apps/desktop/src/backend/DesktopBackendConfiguration.test.ts b/apps/desktop/src/backend/DesktopBackendConfiguration.test.ts index ab57d5db32372..565a50f193e0f 100644 --- a/apps/desktop/src/backend/DesktopBackendConfiguration.test.ts +++ b/apps/desktop/src/backend/DesktopBackendConfiguration.test.ts @@ -29,6 +29,7 @@ const layerShellEnvironment = (prepared = true) => installIntoProcess: Effect.succeed(prepared), awaitDiscovery: Effect.succeed(prepared), awaitUserShellDiscovery: Effect.succeed(prepared), + discoveryFinished: Effect.succeed(true), updates: Stream.empty, }); diff --git a/apps/desktop/src/ipc/methods/window.test.ts b/apps/desktop/src/ipc/methods/window.test.ts index 144dfb27d5892..ea95f6322e899 100644 --- a/apps/desktop/src/ipc/methods/window.test.ts +++ b/apps/desktop/src/ipc/methods/window.test.ts @@ -10,6 +10,7 @@ import * as Path from "effect/Path"; import * as Effect from "effect/Effect"; import * as Layer from "effect/Layer"; import * as Option from "effect/Option"; +import * as Stream from "effect/Stream"; import { vi } from "vite-plus/test"; import type * as Electron from "electron"; @@ -26,6 +27,7 @@ import * as DesktopBackendConfiguration from "../../backend/DesktopBackendConfig import * as DesktopBackendManager from "../../backend/DesktopBackendManager.ts"; import * as DesktopBackendPool from "../../backend/DesktopBackendPool.ts"; import * as DesktopAppSettings from "../../settings/DesktopAppSettings.ts"; +import * as DesktopShellEnvironment from "../../shell/DesktopShellEnvironment.ts"; import * as DesktopManagedPolicy from "../../app/DesktopManagedPolicy.ts"; import * as DesktopWslEnvironment from "../../wsl/DesktopWslEnvironment.ts"; import * as ElectronDialog from "../../electron/ElectronDialog.ts"; @@ -245,17 +247,31 @@ describe("installRelayTelemetryEnabled", () => { removeAllListeners: (channel) => void listeners.delete(channel), on: (channel, listener) => void listeners.set(channel, listener), }; + let discoveryFinished = false; + const ask = () => { + const event = { returnValue: undefined as unknown }; + listeners.get(IpcChannels.GET_RELAY_TELEMETRY_ENABLED_CHANNEL)?.(event as never); + return event.returnValue; + }; yield* installRelayTelemetryEnabled().pipe( Effect.provideService(HostProcess.Environment, env), + Effect.provideService(DesktopShellEnvironment.DesktopShellEnvironment, { + installIntoProcess: Effect.succeed(true), + awaitDiscovery: Effect.succeed(true), + awaitUserShellDiscovery: Effect.succeed(true), + discoveryFinished: Effect.sync(() => discoveryFinished), + updates: Stream.empty, + }), Effect.provide( Layer.mergeAll(DesktopIpc.layerTest(ipcMain), DesktopManagedPolicy.layerTest(policy)), ), ); + // A renderer that asks before the login shell's values are known must not start tracing. + assert.isFalse(ask()); // The login shell's values land in the process env after startup has installed handlers. Object.assign(env, loginShellEnv); - const event = { returnValue: undefined as unknown }; - listeners.get(IpcChannels.GET_RELAY_TELEMETRY_ENABLED_CHANNEL)?.(event as never); - return event.returnValue; + discoveryFinished = true; + return ask(); }).pipe(Effect.scoped); it.effect("reads the desktop host opt-out before returning the renderer policy", () => diff --git a/apps/desktop/src/ipc/methods/window.ts b/apps/desktop/src/ipc/methods/window.ts index da5060d6c0c58..a65f796774d1b 100644 --- a/apps/desktop/src/ipc/methods/window.ts +++ b/apps/desktop/src/ipc/methods/window.ts @@ -34,6 +34,7 @@ import * as DesktopEnvironment from "../../app/DesktopEnvironment.ts"; import * as DesktopManagedPolicy from "../../app/DesktopManagedPolicy.ts"; import * as DesktopPrimaryPaste from "../../app/DesktopPrimaryPaste.ts"; import * as DesktopAppSettings from "../../settings/DesktopAppSettings.ts"; +import * as DesktopShellEnvironment from "../../shell/DesktopShellEnvironment.ts"; import * as DesktopWslBackend from "../../wsl/DesktopWslBackend.ts"; import * as DesktopWslEnvironment from "../../wsl/DesktopWslEnvironment.ts"; import * as ElectronApp from "../../electron/ElectronApp.ts"; @@ -82,8 +83,8 @@ export const getAppBranding = DesktopIpc.makeSyncIpcMethod({ /** * Relay traces leave the machine, so a policy with `telemetry: false`, or one that cannot be read, - * stops them. The policy is read once here: a sync IPC handler cannot wait on the filesystem. The - * environment is read per call because the login shell's values are published after install. + * stops them. Read once here: a sync IPC handler cannot wait on the filesystem. The renderer asks + * once at startup, so until the login shell's environment (which may opt out) is known, say no. */ export const installRelayTelemetryEnabled = Effect.fn("desktop.ipc.window.installRelayTelemetry")( function* () { @@ -93,11 +94,15 @@ export const installRelayTelemetryEnabled = Effect.fn("desktop.ipc.window.instal Effect.map((found) => found?.document.limits?.telemetry !== false), Effect.orElseSucceed(() => false), ); + const shellEnvironment = yield* DesktopShellEnvironment.DesktopShellEnvironment; yield* ipc.handleSync( DesktopIpc.makeSyncIpcMethod({ channel: IpcChannels.GET_RELAY_TELEMETRY_ENABLED_CHANNEL, result: Schema.Boolean, - handler: () => Effect.sync(() => policyAllows && isRelayTracingEnabled(env)), + handler: () => + shellEnvironment.discoveryFinished.pipe( + Effect.map((known) => known && policyAllows && isRelayTracingEnabled(env)), + ), }), ); }, diff --git a/apps/desktop/src/shell/DesktopShellEnvironment.ts b/apps/desktop/src/shell/DesktopShellEnvironment.ts index 0ef7ac2368212..efaade93122f6 100644 --- a/apps/desktop/src/shell/DesktopShellEnvironment.ts +++ b/apps/desktop/src/shell/DesktopShellEnvironment.ts @@ -93,6 +93,8 @@ export class DesktopShellEnvironment extends Context.Service< readonly awaitDiscovery: Effect.Effect; /** Whether the user's own login shell, not a fallback, gave the PATH a new terminal gets. */ readonly awaitUserShellDiscovery: Effect.Effect; + /** Whether the first discovery has finished, for callers that cannot wait on it. */ + readonly discoveryFinished: Effect.Effect; readonly updates: Stream.Stream; } >()("@t3tools/desktop/shell/DesktopShellEnvironment") {} @@ -797,6 +799,7 @@ export const make = Effect.gen(function* () { Effect.andThen(Deferred.await(discovered)), Effect.map(({ fromUserShell }) => fromUserShell), ), + discoveryFinished: Deferred.isDone(discovered), updates, }); }); diff --git a/apps/desktop/src/telemetry/DesktopTelemetryPublisher.test.ts b/apps/desktop/src/telemetry/DesktopTelemetryPublisher.test.ts index e2bfabe32762c..3b0582e8131b7 100644 --- a/apps/desktop/src/telemetry/DesktopTelemetryPublisher.test.ts +++ b/apps/desktop/src/telemetry/DesktopTelemetryPublisher.test.ts @@ -93,6 +93,7 @@ describe("DesktopTelemetryPublisher", () => { installIntoProcess: Effect.succeed(true), awaitDiscovery: Effect.succeed(true), awaitUserShellDiscovery: Effect.succeed(true), + discoveryFinished: Effect.succeed(true), updates: Stream.make({ version: 1, type: "shellEnvironment", From 1bebc6628cc542ed5b2473c828643ff75b121347 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Mon, 16 Nov 2026 22:10:23 +0000 Subject: [PATCH 4/5] fix(desktop): enable relay tracing once the login shell is read Answering false while shell discovery was pending turned relay tracing off for the whole renderer session, because the renderer asks once at startup. The desktop host now answers null until it has read the login shell, and the renderer keeps relay spans local until it gets a definite answer, caching that answer so it stops asking. Co-Authored-By: Claude Opus 5.5 --- apps/desktop/src/ipc/methods/window.test.ts | 31 +++++++++++++-------- apps/desktop/src/ipc/methods/window.ts | 10 ++++--- apps/desktop/src/preload.ts | 6 ++-- apps/web/src/cloud/publicConfig.ts | 11 +++++++- apps/web/src/lib/runtime.test.ts | 16 +++++++++++ apps/web/src/lib/runtime.ts | 24 ++++++++++------ packages/contracts/src/ipc.ts | 3 +- packages/shared/src/relayTracing.ts | 17 ++++++++++- 8 files changed, 89 insertions(+), 29 deletions(-) diff --git a/apps/desktop/src/ipc/methods/window.test.ts b/apps/desktop/src/ipc/methods/window.test.ts index ea95f6322e899..b256025eff844 100644 --- a/apps/desktop/src/ipc/methods/window.test.ts +++ b/apps/desktop/src/ipc/methods/window.test.ts @@ -266,20 +266,27 @@ describe("installRelayTelemetryEnabled", () => { Layer.mergeAll(DesktopIpc.layerTest(ipcMain), DesktopManagedPolicy.layerTest(policy)), ), ); - // A renderer that asks before the login shell's values are known must not start tracing. - assert.isFalse(ask()); + const beforeDiscovery = ask(); // The login shell's values land in the process env after startup has installed handlers. Object.assign(env, loginShellEnv); discoveryFinished = true; - return ask(); + return { beforeDiscovery, afterDiscovery: ask() }; }).pipe(Effect.scoped); it.effect("reads the desktop host opt-out before returning the renderer policy", () => Effect.gen(function* () { - assert.isFalse(yield* relayTelemetryEnabled({ T3CODE_TELEMETRY_ENABLED: "false" })); - assert.isTrue(yield* relayTelemetryEnabled({})); - assert.isFalse( + assert.deepEqual(yield* relayTelemetryEnabled({ T3CODE_TELEMETRY_ENABLED: "false" }), { + beforeDiscovery: false, + afterDiscovery: false, + }); + // Undecided until the login shell is read, so the renderer asks again instead of opting out. + assert.deepEqual(yield* relayTelemetryEnabled({}), { + beforeDiscovery: null, + afterDiscovery: true, + }); + assert.deepEqual( yield* relayTelemetryEnabled({}, undefined, { T3CODE_TELEMETRY_ENABLED: "false" }), + { beforeDiscovery: null, afterDiscovery: false }, ); }), ); @@ -291,14 +298,14 @@ describe("installRelayTelemetryEnabled", () => { organization: "Example Corp", limits, }); - assert.isFalse(yield* relayTelemetryEnabled({}, policy({ telemetry: false }))); - assert.isTrue(yield* relayTelemetryEnabled({}, policy({ webhookTasks: false }))); + const after = function* (...args: Parameters) { + return (yield* relayTelemetryEnabled(...args)).afterDiscovery; + }; + assert.isFalse(yield* after({}, policy({ telemetry: false }))); + assert.isTrue(yield* after({}, policy({ webhookTasks: false }))); // A policy that cannot be read fails closed. assert.isFalse( - yield* relayTelemetryEnabled( - {}, - new ManagedPolicyFileError({ path: "/test", reason: "bad JSON" }), - ), + yield* after({}, new ManagedPolicyFileError({ path: "/test", reason: "bad JSON" })), ); }), ); diff --git a/apps/desktop/src/ipc/methods/window.ts b/apps/desktop/src/ipc/methods/window.ts index a65f796774d1b..2545cb9dc5390 100644 --- a/apps/desktop/src/ipc/methods/window.ts +++ b/apps/desktop/src/ipc/methods/window.ts @@ -83,8 +83,8 @@ export const getAppBranding = DesktopIpc.makeSyncIpcMethod({ /** * Relay traces leave the machine, so a policy with `telemetry: false`, or one that cannot be read, - * stops them. Read once here: a sync IPC handler cannot wait on the filesystem. The renderer asks - * once at startup, so until the login shell's environment (which may opt out) is known, say no. + * stops them. Read once here: a sync IPC handler cannot wait on the filesystem. Until the login + * shell's environment (which may opt out) is known, answer null so the renderer asks again. */ export const installRelayTelemetryEnabled = Effect.fn("desktop.ipc.window.installRelayTelemetry")( function* () { @@ -98,10 +98,12 @@ export const installRelayTelemetryEnabled = Effect.fn("desktop.ipc.window.instal yield* ipc.handleSync( DesktopIpc.makeSyncIpcMethod({ channel: IpcChannels.GET_RELAY_TELEMETRY_ENABLED_CHANNEL, - result: Schema.Boolean, + result: Schema.NullOr(Schema.Boolean), handler: () => shellEnvironment.discoveryFinished.pipe( - Effect.map((known) => known && policyAllows && isRelayTracingEnabled(env)), + Effect.map((known) => + !policyAllows || !isRelayTracingEnabled(env) ? false : known ? true : null, + ), ), }), ); diff --git a/apps/desktop/src/preload.ts b/apps/desktop/src/preload.ts index c215c4b2e639f..b4b15f6a7a4eb 100644 --- a/apps/desktop/src/preload.ts +++ b/apps/desktop/src/preload.ts @@ -111,8 +111,10 @@ contextBridge.exposeInMainWorld("desktopBridge", { } return result as ReturnType; }, - getRelayTelemetryEnabled: () => - ipcRenderer.sendSync(IpcChannels.GET_RELAY_TELEMETRY_ENABLED_CHANNEL) === true, + getRelayTelemetryEnabled: () => { + const enabled = ipcRenderer.sendSync(IpcChannels.GET_RELAY_TELEMETRY_ENABLED_CHANNEL); + return enabled === null ? null : enabled === true; + }, getPathForFile: (file: File) => webUtils.getPathForFile(file), getClientPlatform: () => clientPlatform, restartAudioService: () => ipcRenderer.invoke(IpcChannels.RESTART_AUDIO_SERVICE_CHANNEL), diff --git a/apps/web/src/cloud/publicConfig.ts b/apps/web/src/cloud/publicConfig.ts index f7f53ca2c3e4f..ec9cf15bb7e42 100644 --- a/apps/web/src/cloud/publicConfig.ts +++ b/apps/web/src/cloud/publicConfig.ts @@ -61,9 +61,18 @@ export function resolveCloudPublicConfig(): CloudPublicConfig { }; } +let desktopRelayTelemetry: boolean | null = null; + +/** Whether relay spans may be exported now; the desktop host may not know yet at startup. */ +export function relayTelemetryEnabled(): boolean | null { + if (typeof window === "undefined" || !window.desktopBridge) return true; + desktopRelayTelemetry ??= window.desktopBridge.getRelayTelemetryEnabled(); + return desktopRelayTelemetry; +} + export function resolveRelayTracingConfig() { // The relay exporter is created during module initialization, so this must be synchronous. - if (typeof window !== "undefined" && window.desktopBridge?.getRelayTelemetryEnabled() === false) { + if (relayTelemetryEnabled() === false) { return null; } const { relayTracing } = resolveCloudPublicConfig(); diff --git a/apps/web/src/lib/runtime.test.ts b/apps/web/src/lib/runtime.test.ts index 22e362ddd2e81..4c0e5da91524e 100644 --- a/apps/web/src/lib/runtime.test.ts +++ b/apps/web/src/lib/runtime.test.ts @@ -8,6 +8,11 @@ afterEach(() => { vi.unstubAllGlobals(); }); +const answers = (...values: Array) => { + let call = 0; + return () => values[Math.min(call++, values.length - 1)] ?? null; +}; + describe("web runtime relay telemetry policy", () => { it.each([ { @@ -20,6 +25,17 @@ describe("web runtime relay telemetry policy", () => { desktopBridge: { getRelayTelemetryEnabled: () => true }, exports: true, }, + { + // The desktop host reads the login shell after the renderer has started. + surface: "desktop enabled once the login shell is read", + desktopBridge: { getRelayTelemetryEnabled: answers(null, true) }, + exports: true, + }, + { + surface: "desktop opt-out found in the login shell", + desktopBridge: { getRelayTelemetryEnabled: answers(null, false, true) }, + exports: false, + }, { surface: "ordinary browser ignores host opt-out", desktopBridge: undefined, diff --git a/apps/web/src/lib/runtime.ts b/apps/web/src/lib/runtime.ts index 4795655be0260..51af0894686d4 100644 --- a/apps/web/src/lib/runtime.ts +++ b/apps/web/src/lib/runtime.ts @@ -10,7 +10,11 @@ import * as PrimaryEnvironmentHttpLayer from "../environments/primary/httpLayer" import * as Dpop from "../cloud/dpop"; import * as ManagedRelayLayer from "../cloud/managedRelayLayer"; -import { resolveCloudPublicConfig, resolveRelayTracingConfig } from "../cloud/publicConfig"; +import { + relayTelemetryEnabled, + resolveCloudPublicConfig, + resolveRelayTracingConfig, +} from "../cloud/publicConfig"; import * as ClientTracer from "../observability/clientTracer"; function configuredRelayUrl(): string { @@ -18,13 +22,17 @@ function configuredRelayUrl(): string { } const layerHttpClient = layerRemoteHttpClient((input, init) => globalThis.fetch(input, init)); -const layerRelayTracing = RelayTracing.layer(resolveRelayTracingConfig(), { - serviceName: "t3code-web", - serviceVersion: import.meta.env.APP_VERSION, - runtime: "browser", - serviceInstanceId: ClientTracer.serviceInstanceId, - client: typeof window !== "undefined" && window.desktopBridge ? "desktop" : "web", -}).pipe(Layer.provide(layerHttpClient)); +const layerRelayTracing = RelayTracing.layer( + resolveRelayTracingConfig(), + { + serviceName: "t3code-web", + serviceVersion: import.meta.env.APP_VERSION, + runtime: "browser", + serviceInstanceId: ClientTracer.serviceInstanceId, + client: typeof window !== "undefined" && window.desktopBridge ? "desktop" : "web", + }, + { isEnabled: () => relayTelemetryEnabled() === true }, +).pipe(Layer.provide(layerHttpClient)); type RuntimeLayerSource = | typeof layerHttpClient diff --git a/packages/contracts/src/ipc.ts b/packages/contracts/src/ipc.ts index 96942123f56d3..b44f8e77f239a 100644 --- a/packages/contracts/src/ipc.ts +++ b/packages/contracts/src/ipc.ts @@ -1058,7 +1058,8 @@ export type SystemSettingsPane = typeof SystemSettingsPaneSchema.Type; export interface DesktopBridge { getAppBranding: () => DesktopAppBranding | null; - getRelayTelemetryEnabled: () => boolean; + /** `null` until the desktop host has read the login shell's environment; ask again later. */ + getRelayTelemetryEnabled: () => boolean | null; getPathForFile: (file: File) => string; getClientPlatform: () => string; restartAudioService?: () => Promise; diff --git a/packages/shared/src/relayTracing.ts b/packages/shared/src/relayTracing.ts index 6195a8c2832e5..61a6e92b2b402 100644 --- a/packages/shared/src/relayTracing.ts +++ b/packages/shared/src/relayTracing.ts @@ -139,9 +139,18 @@ export function nonInterferingTracer(delegate: Tracer.Tracer): Tracer.Tracer { }); } +/** Spans started while `isEnabled` says no stay local instead of being exported. */ +function gatedTracer(delegate: Tracer.Tracer, isEnabled: () => boolean): Tracer.Tracer { + return Tracer.make({ + span: (options) => (isEnabled() ? delegate.span(options) : Tracer.nativeTracer.span(options)), + ...(delegate.context ? { context: delegate.context } : {}), + }); +} + export function layer( config: RelayClientTracingConfig | null, resource: RelayClientTracingResource, + options?: { readonly isEnabled?: () => boolean }, ): Layer.Layer { if (config === null) { return Layer.succeed(RelayClientTracer, Option.none()); @@ -169,6 +178,12 @@ export function layer( return Layer.effect( RelayClientTracer, - Tracer.Tracer.pipe(Effect.map(nonInterferingTracer), Effect.asSome), + Tracer.Tracer.pipe( + Effect.map(nonInterferingTracer), + Effect.map((tracer) => + options?.isEnabled ? gatedTracer(tracer, options.isEnabled) : tracer, + ), + Effect.asSome, + ), ).pipe(Layer.provide(layerTracer)); } From 50ee395e3810f2aa04e4737c3ebb78b740a53680 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Mon, 16 Nov 2026 22:23:52 +0000 Subject: [PATCH 5/5] fix(desktop): settle shell discovery only after the user's shell answers discoveryFinished turned true when the first probe ended, even when only a fallback shell had answered and the user's own shell was still being retried. A renderer could then cache relay telemetry as enabled before a retry found T3CODE_TELEMETRY_ENABLED=false. Report it only once the refresh sequence ends: the user's shell answered or the retries ran out. Co-Authored-By: Claude Opus 5.5 --- apps/desktop/src/shell/DesktopShellEnvironment.test.ts | 2 ++ apps/desktop/src/shell/DesktopShellEnvironment.ts | 6 ++++-- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/apps/desktop/src/shell/DesktopShellEnvironment.test.ts b/apps/desktop/src/shell/DesktopShellEnvironment.test.ts index 13f9bc85be945..f082020a5dec1 100644 --- a/apps/desktop/src/shell/DesktopShellEnvironment.test.ts +++ b/apps/desktop/src/shell/DesktopShellEnvironment.test.ts @@ -713,6 +713,8 @@ describe("DesktopShellEnvironment", () => { Effect.gen(function* () { assert.isTrue(yield* service.awaitDiscovery); assert.equal(env.PATH, "/usr/bin"); + // The user's shell may still opt out of telemetry, so discovery has not settled. + assert.isFalse(yield* service.discoveryFinished); // The Linux probe checks the D-Bus socket on the real filesystem, which the clock does not await. const published = yield* service.updates.pipe( Stream.filter((snapshot) => snapshot.environment.PATH === "/fish/bin:/usr/bin"), diff --git a/apps/desktop/src/shell/DesktopShellEnvironment.ts b/apps/desktop/src/shell/DesktopShellEnvironment.ts index efaade93122f6..1bd3386a1a2e6 100644 --- a/apps/desktop/src/shell/DesktopShellEnvironment.ts +++ b/apps/desktop/src/shell/DesktopShellEnvironment.ts @@ -93,7 +93,7 @@ export class DesktopShellEnvironment extends Context.Service< readonly awaitDiscovery: Effect.Effect; /** Whether the user's own login shell, not a fallback, gave the PATH a new terminal gets. */ readonly awaitUserShellDiscovery: Effect.Effect; - /** Whether the first discovery has finished, for callers that cannot wait on it. */ + /** Whether discovery has settled (the user's shell answered or retries ran out), without waiting. */ readonly discoveryFinished: Effect.Effect; readonly updates: Stream.Stream; } @@ -675,6 +675,7 @@ export const make = Effect.gen(function* () { const changes = yield* PubSub.unbounded(); const latest = yield* Ref.make>(Option.none()); const discovered = yield* Deferred.make(); + const settledDiscovery = yield* Deferred.make(); const publish = Effect.fn("desktop.shellEnvironment.publish")(function* ( patch: ShellEnvironmentPatch, discovered = false, @@ -744,6 +745,7 @@ export const make = Effect.gen(function* () { ), ), ), + Effect.onExit(() => Deferred.succeed(settledDiscovery, undefined)), ); const installIntoProcess = yield* Effect.cached( Effect.gen(function* () { @@ -799,7 +801,7 @@ export const make = Effect.gen(function* () { Effect.andThen(Deferred.await(discovered)), Effect.map(({ fromUserShell }) => fromUserShell), ), - discoveryFinished: Deferred.isDone(discovered), + discoveryFinished: Deferred.isDone(settledDiscovery), updates, }); });