Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
fix(desktop): Niri/Hyprland - Linux secret storage backend (#2916)
Mike Olson6f04a5cffb8f
diff --git a/apps/desktop/src/app/DesktopApp.ts b/apps/desktop/src/app/DesktopApp.tsindex dd7f44edf..410184053 100644--- a/apps/desktop/src/app/DesktopApp.ts+++ b/apps/desktop/src/app/DesktopApp.ts@@ -9,6 +9,7 @@ import * as Crypto from "effect/Crypto";import * as ElectronApp from "../electron/ElectronApp.ts";import * as ElectronDialog from "../electron/ElectronDialog.ts";import * as ElectronProtocol from "../electron/ElectronProtocol.ts";+import * as ElectronSafeStorage from "../electron/ElectronSafeStorage.ts";import { installDesktopIpcHandlers } from "../ipc/DesktopIpcHandlers.ts";import * as DesktopAppIdentity from "./DesktopAppIdentity.ts";import * as DesktopClerk from "./DesktopClerk.ts";@@ -19,6 +20,7 @@ import * as DesktopEnvironment from "./DesktopEnvironment.ts";import * as DesktopLifecycle from "./DesktopLifecycle.ts";import * as DesktopLinuxUrlHandler from "./DesktopLinuxUrlHandler.ts";import * as DesktopObservability from "./DesktopObservability.ts";+import * as DesktopPreReadyPlatform from "./DesktopPreReadyPlatform.ts";import * as DesktopShutdown from "./DesktopShutdown.ts";import * as DesktopServerExposure from "../backend/DesktopServerExposure.ts";import * as DesktopAppSettings from "../settings/DesktopAppSettings.ts";@@ -225,17 +227,45 @@ const startup = Effect.gen(function* () {const clerk = yield* DesktopClerk.DesktopClerk;const shellEnvironment = yield* DesktopShellEnvironment.DesktopShellEnvironment;const desktopSettings = yield* DesktopAppSettings.DesktopAppSettings;+ const preReadyElectronOptions = yield* DesktopPreReadyPlatform.DesktopPreReadyElectronOptions;+ const safeStorage = yield* ElectronSafeStorage.ElectronSafeStorage;const updates = yield* DesktopUpdates.DesktopUpdates;const environment = yield* DesktopEnvironment.DesktopEnvironment;yield* shellEnvironment.installIntoProcess;+ const hasCommandLinePasswordStore =+ preReadyElectronOptions.linuxPasswordStoreCommandLine !== null;+ const linuxElectronOptions =+ environment.platform === "linux" && !hasCommandLinePasswordStore+ ? DesktopPreReadyPlatform.resolveEarlyLinuxElectronOptionsFromProcess()+ : preReadyElectronOptions.linux;+ if (linuxElectronOptions !== null && !hasCommandLinePasswordStore) {+ if (+ linuxElectronOptions.passwordStore !== null ||+ preReadyElectronOptions.linux?.passwordStore !== null+ ) {+ yield* electronApp.removeCommandLineSwitch("password-store");+ }+ if (linuxElectronOptions.passwordStore !== null) {+ yield* electronApp.appendCommandLineSwitch(+ "password-store",+ linuxElectronOptions.passwordStore,+ );+ }+ }const userDataPath = yield* appIdentity.resolveUserDataPath;yield* electronApp.setPath("userData", userDataPath);yield* logStartupInfo("runtime logging configured", { logDir: environment.logDir });yield* desktopSettings.load;- if (environment.platform === "linux") {- yield* electronApp.appendCommandLineSwitch("class", environment.linuxWmClass);+ if (linuxElectronOptions !== null) {+ yield* logStartupInfo("linux password store configured", {+ passwordStore: hasCommandLinePasswordStore+ ? "command-line"+ : (linuxElectronOptions.passwordStore ?? "electron-default"),+ xdgCurrentDesktop: process.env.XDG_CURRENT_DESKTOP ?? null,+ xdgSessionDesktop: process.env.XDG_SESSION_DESKTOP ?? null,+ });}yield* appIdentity.configure;@@ -247,6 +277,12 @@ const startup = Effect.gen(function* () {Effect.catchCause((cause) => fatalStartupCause("whenReady", cause)),);yield* logStartupInfo("app ready");+ if (environment.platform === "linux") {+ const selectedBackend = yield* safeStorage.selectedStorageBackend;+ yield* logStartupInfo("safe storage ready", {+ backend: Option.getOrElse(selectedBackend, () => "unknown"),+ });+ }yield* appIdentity.configure;yield* applicationMenu.configure;yield* updates.configure;diff --git a/apps/desktop/src/app/DesktopAppIdentity.test.ts b/apps/desktop/src/app/DesktopAppIdentity.test.tsindex 6c5385e70..de945054c 100644--- a/apps/desktop/src/app/DesktopAppIdentity.test.ts+++ b/apps/desktop/src/app/DesktopAppIdentity.test.ts@@ -64,6 +64,7 @@ const makeElectronAppLayer = (calls: ElectronAppCalls) =>}),appendCommandLineSwitch: () => Effect.void,onBeforeQuitForUpdate: () => Effect.void,+ removeCommandLineSwitch: () => Effect.void,on: () => Effect.void,} satisfies ElectronApp.ElectronApp["Service"]);diff --git a/apps/desktop/src/app/DesktopConnectionCatalogStore.test.ts b/apps/desktop/src/app/DesktopConnectionCatalogStore.test.tsindex 7c7818994..c58830b30 100644--- a/apps/desktop/src/app/DesktopConnectionCatalogStore.test.ts+++ b/apps/desktop/src/app/DesktopConnectionCatalogStore.test.ts@@ -39,6 +39,7 @@ function makeSafeStorageLayer(available: boolean, failDecrypt: Ref.Ref<boolean>return decoded.slice("encrypted:".length);});},+ selectedStorageBackend: Effect.succeed(Option.none()),} satisfies ElectronSafeStorage.ElectronSafeStorage["Service"]);}diff --git a/apps/desktop/src/app/DesktopEarlyElectronStartup.test.ts b/apps/desktop/src/app/DesktopEarlyElectronStartup.test.tsnew file mode 100644index 000000000..b7647b5cc--- /dev/null+++ b/apps/desktop/src/app/DesktopEarlyElectronStartup.test.ts@@ -0,0 +1,121 @@+// @effect-diagnostics nodeBuiltinImport:off - tests use POSIX path joining to match the Linux startup boundary.+import * as NodePath from "node:path";+import { assert, describe, it } from "@effect/vitest";++import {+ resolveEarlyLinuxElectronOptions,+ resolveEarlyLinuxPasswordStorePreference,+} from "./DesktopEarlyElectronStartup.ts";++describe("DesktopEarlyElectronStartup", () => {+ const joinPath = NodePath.posix.join;++ it("reads the persisted linux password-store preference before Electron is ready", () => {+ const preference = resolveEarlyLinuxPasswordStorePreference({+ env: { T3CODE_HOME: "/home/user/.t3-test" },+ homeDirectory: "/home/user",+ joinPath,+ readFileString: (path) => {+ assert.equal(path, "/home/user/.t3-test/userdata/desktop-settings.json");+ return JSON.stringify({ linuxPasswordStore: "kwallet6" });+ },+ });++ assert.equal(preference, "kwallet6");+ });++ it("accepts JSONC in the early desktop settings file", () => {+ const preference = resolveEarlyLinuxPasswordStorePreference({+ env: { T3CODE_HOME: "/home/user/.t3-test" },+ homeDirectory: "/home/user",+ joinPath,+ readFileString: () => `{+ // manually edited setting+ "linuxPasswordStore": "gnome-libsecret",+ }`,+ });++ assert.equal(preference, "gnome-libsecret");+ });++ it("falls back to auto when the early settings document is missing or invalid", () => {+ const preference = resolveEarlyLinuxPasswordStorePreference({+ env: {},+ homeDirectory: "/home/user",+ joinPath,+ readFileString: () => {+ throw new Error("missing");+ },+ });++ assert.equal(preference, "auto");+ });++ it("preserves absolute root paths when resolving early settings", () => {+ const preference = resolveEarlyLinuxPasswordStorePreference({+ env: { T3CODE_HOME: "/" },+ homeDirectory: "/home/user",+ joinPath,+ readFileString: (path) => {+ assert.equal(path, "/userdata/desktop-settings.json");+ return JSON.stringify({ linuxPasswordStore: "kwallet6" });+ },+ });++ assert.equal(preference, "kwallet6");+ });++ it("resolves the early linux Electron switches", () => {+ const options = resolveEarlyLinuxElectronOptions({+ env: {+ T3CODE_HOME: "/home/user/.t3-test",+ XDG_CURRENT_DESKTOP: "niri",+ VITE_DEV_SERVER_URL: "http://127.0.0.1:5173",+ },+ homeDirectory: "/home/user",+ joinPath,+ readFileString: (path) => {+ assert.equal(path, "/home/user/.t3-test/userdata/desktop-settings.json");+ return JSON.stringify({ linuxPasswordStore: "auto" });+ },+ });++ assert.deepEqual(options, {+ linuxWmClass: "t3code-dev",+ passwordStore: "gnome-libsecret",+ });+ });++ it("keeps implicit development state under ~/.t3/dev when T3CODE_HOME is unset", () => {+ const preference = resolveEarlyLinuxPasswordStorePreference({+ env: {+ VITE_DEV_SERVER_URL: "http://127.0.0.1:5173",+ },+ homeDirectory: "/home/user",+ joinPath,+ readFileString: (path) => {+ assert.equal(path, "/home/user/.t3/dev/desktop-settings.json");+ return JSON.stringify({ linuxPasswordStore: "kwallet" });+ },+ });++ assert.equal(preference, "kwallet");+ });++ it("treats whitespace-only T3CODE_HOME as unconfigured in development", () => {+ const preference = resolveEarlyLinuxPasswordStorePreference({+ env: {+ T3CODE_HOME: " ",+ VITE_DEV_SERVER_URL: "http://127.0.0.1:5173",+ },+ homeDirectory: "/home/user",+ joinPath,+ readFileString: (path) => {+ assert.equal(path, "/home/user/.t3/dev/desktop-settings.json");+ return JSON.stringify({ linuxPasswordStore: "gnome-libsecret" });+ },+ });++ assert.equal(preference, "gnome-libsecret");+ });+});diff --git a/apps/desktop/src/app/DesktopEarlyElectronStartup.ts b/apps/desktop/src/app/DesktopEarlyElectronStartup.tsnew file mode 100644index 000000000..3e11d7961--- /dev/null+++ b/apps/desktop/src/app/DesktopEarlyElectronStartup.ts@@ -0,0 +1,90 @@+import { fromLenientJson } from "@t3tools/shared/schemaJson";+import * as Option from "effect/Option";+import * as Schema from "effect/Schema";++import {+ DEFAULT_LINUX_PASSWORD_STORE,+ normalizeLinuxPasswordStorePreference,+ resolveLinuxPasswordStoreSwitch,+ type LinuxPasswordStoreSwitch,+ type LinuxPasswordStorePreference,+} from "../linuxSecretStorage.ts";+import {+ resolveDesktopBaseDir,+ resolveDesktopStateDir,+ type JoinPath,+} from "./DesktopStatePaths.ts";++interface EarlyDesktopSettingsInput {+ readonly env: NodeJS.ProcessEnv;+ readonly homeDirectory: string;+ readonly joinPath: JoinPath;+ readonly readFileString: (path: string) => string;+}++type EarlyLinuxElectronOptionsInput = EarlyDesktopSettingsInput;++export interface EarlyLinuxElectronOptions {+ readonly linuxWmClass: string;+ readonly passwordStore: LinuxPasswordStoreSwitch | null;+}++const trimNonEmpty = (value: string | undefined): string | null => {+ const trimmed = value?.trim();+ return trimmed && trimmed.length > 0 ? trimmed : null;+};++const EarlyDesktopSettingsJson = fromLenientJson(+ Schema.Struct({+ linuxPasswordStore: Schema.optionalKey(Schema.Unknown),+ }),+);+const decodeEarlyDesktopSettingsJson = Schema.decodeSync(EarlyDesktopSettingsJson);++const isDevelopmentEnvironment = (env: NodeJS.ProcessEnv): boolean =>+ trimNonEmpty(env.VITE_DEV_SERVER_URL) !== null;++function resolveEarlyDesktopSettingsPath(input: {+ readonly env: NodeJS.ProcessEnv;+ readonly homeDirectory: string;+ readonly joinPath: JoinPath;+}): string {+ const t3Home = Option.fromUndefinedOr(input.env.T3CODE_HOME);+ const baseDir = resolveDesktopBaseDir({+ homeDirectory: input.homeDirectory,+ joinPath: input.joinPath,+ t3Home,+ });+ const stateDir = resolveDesktopStateDir({+ baseDir,+ isDevelopment: isDevelopmentEnvironment(input.env),+ joinPath: input.joinPath,+ t3Home,+ });+ return input.joinPath(stateDir, "desktop-settings.json");+}++export function resolveEarlyLinuxPasswordStorePreference(+ input: EarlyDesktopSettingsInput,+): LinuxPasswordStorePreference {+ const settingsPath = resolveEarlyDesktopSettingsPath(input);+ try {+ const parsed = decodeEarlyDesktopSettingsJson(input.readFileString(settingsPath));+ return normalizeLinuxPasswordStorePreference(parsed.linuxPasswordStore);+ } catch {+ return DEFAULT_LINUX_PASSWORD_STORE;+ }+}++export function resolveEarlyLinuxElectronOptions(+ input: EarlyLinuxElectronOptionsInput,+): EarlyLinuxElectronOptions {+ const preference = resolveEarlyLinuxPasswordStorePreference(input);+ return {+ linuxWmClass: isDevelopmentEnvironment(input.env) ? "t3code-dev" : "t3code",+ passwordStore: resolveLinuxPasswordStoreSwitch({+ preference,+ env: input.env,+ }),+ };+}diff --git a/apps/desktop/src/app/DesktopEnvironment.ts b/apps/desktop/src/app/DesktopEnvironment.tsindex f9a603ca6..1806289a0 100644--- a/apps/desktop/src/app/DesktopEnvironment.ts+++ b/apps/desktop/src/app/DesktopEnvironment.ts@@ -13,6 +13,7 @@ import * as Path from "effect/Path";import * as DesktopAppSettings from "../settings/DesktopAppSettings.ts";import * as DesktopConfig from "./DesktopConfig.ts";+import { resolveDesktopBaseDir, resolveDesktopStateDir } from "./DesktopStatePaths.ts";import { isNightlyDesktopVersion } from "../updates/updateChannels.ts";export interface MakeDesktopEnvironmentInput {@@ -149,8 +150,11 @@ const make = Effect.fn("desktop.environment.make")(function* (: input.platform === "darwin"? path.join(homeDirectory, "Library", "Application Support"): Option.getOrElse(config.xdgConfigHome, () => path.join(homeDirectory, ".config"));- const configuredBaseDir = config.t3Home;- const baseDir = Option.getOrElse(configuredBaseDir, () => path.join(homeDirectory, ".t3"));+ const baseDir = resolveDesktopBaseDir({+ homeDirectory,+ joinPath: path.join,+ t3Home: config.t3Home,+ });const rootDir = path.resolve(input.dirname, "../../..");const appRoot = input.isPackaged ? input.appPath : rootDir;const branding = resolveDesktopAppBranding({@@ -158,10 +162,12 @@ const make = Effect.fn("desktop.environment.make")(function* (appVersion: input.appVersion,});const displayName = branding.displayName;- const stateDir = path.join(+ const stateDir = resolveDesktopStateDir({baseDir,- isDevelopment && Option.isNone(configuredBaseDir) ? "dev" : "userdata",- );+ isDevelopment,+ joinPath: path.join,+ t3Home: config.t3Home,+ });const userDataDirName = isDevelopment ? "t3code-dev" : "t3code";const legacyUserDataDirName = isDevelopment ? "T3 Code (Dev)" : "T3 Code (Alpha)";const linuxApplicationsDir = path.join(diff --git a/apps/desktop/src/app/DesktopLifecycle.test.ts b/apps/desktop/src/app/DesktopLifecycle.test.tsindex 978e000a7..be9d7f345 100644--- a/apps/desktop/src/app/DesktopLifecycle.test.ts+++ b/apps/desktop/src/app/DesktopLifecycle.test.ts@@ -35,6 +35,7 @@ describe("DesktopLifecycle", () => {setDesktopName: () => Effect.void,setDockIcon: () => Effect.void,appendCommandLineSwitch: () => Effect.void,+ removeCommandLineSwitch: () => Effect.void,onBeforeQuitForUpdate: (listener) =>Effect.acquireRelease(Effect.sync(() => {diff --git a/apps/desktop/src/app/DesktopPreReadyPlatform.test.ts b/apps/desktop/src/app/DesktopPreReadyPlatform.test.tsnew file mode 100644index 000000000..a29e0fd3b--- /dev/null+++ b/apps/desktop/src/app/DesktopPreReadyPlatform.test.ts@@ -0,0 +1,130 @@+import { assert, describe, it } from "@effect/vitest";+import { HostProcessPlatform } from "@t3tools/shared/hostProcess";+import * as Context from "effect/Context";+import * as Effect from "effect/Effect";+import * as Layer from "effect/Layer";+import { beforeEach, vi } from "vite-plus/test";++const { appendSwitchMock, getSwitchValueMock, hasSwitchMock, registerSchemesMock } = vi.hoisted(+ () => ({+ appendSwitchMock: vi.fn(),+ getSwitchValueMock: vi.fn(),+ hasSwitchMock: vi.fn(),+ registerSchemesMock: vi.fn(),+ }),+);++vi.mock("electron", () => ({+ app: {+ commandLine: {+ appendSwitch: appendSwitchMock,+ getSwitchValue: getSwitchValueMock,+ hasSwitch: hasSwitchMock,+ },+ },+ protocol: {+ registerSchemesAsPrivileged: registerSchemesMock,+ },+}));++import * as DesktopPreReadyPlatform from "./DesktopPreReadyPlatform.ts";++describe("DesktopPreReadyPlatform", () => {+ beforeEach(() => {+ appendSwitchMock.mockReset();+ getSwitchValueMock.mockReset();+ hasSwitchMock.mockReset();+ registerSchemesMock.mockReset();+ });++ it("reads an explicit Electron command-line switch value", () => {+ const value = DesktopPreReadyPlatform.readCommandLineSwitchValue(+ {+ hasSwitch: (switchName) => switchName === "password-store",+ getSwitchValue: (switchName) => {+ assert.equal(switchName, "password-store");+ return "basic";+ },+ },+ "password-store",+ );++ assert.equal(value, "basic");+ });++ it("treats valueless Electron command-line switches as absent", () => {+ const value = DesktopPreReadyPlatform.readCommandLineSwitchValue(+ {+ hasSwitch: () => true,+ getSwitchValue: () => "",+ },+ "password-store",+ );++ assert.isNull(value);+ });++ it("returns null for missing Electron command-line switches", () => {+ const value = DesktopPreReadyPlatform.readCommandLineSwitchValue(+ {+ hasSwitch: () => false,+ getSwitchValue: () => {+ throw new Error("Unexpected switch value read.");+ },+ },+ "password-store",+ );++ assert.isNull(value);+ });++ it.effect(+ "acquires a synchronous pre-ready layer before an asynchronous Clerk-shaped layer",+ () =>+ Effect.gen(function* () {+ class ClerkShaped extends Context.Service<ClerkShaped, { readonly ready: true }>()(+ "@t3tools/desktop/app/DesktopPreReadyPlatform.test/ClerkShaped",+ ) {}++ const events: Array<string> = [];+ registerSchemesMock.mockImplementation(() => {+ events.push("pre-ready");+ });++ const preReadyLayer = DesktopPreReadyPlatform.layer.pipe(+ Layer.provide(Layer.succeed(HostProcessPlatform, "darwin")),+ );++ const clerkShapedLayer = Layer.effect(+ ClerkShaped,+ Effect.promise(() => Promise.resolve()).pipe(+ Effect.map(() => {+ events.push("clerk");+ return { ready: true as const };+ }),+ ),+ );++ const runtimeLayer = clerkShapedLayer.pipe(+ Layer.flatMap((clerkContext) => Layer.succeedContext(clerkContext)),+ Layer.provideMerge(preReadyLayer),+ );++ const result = yield* Effect.all({+ clerk: ClerkShaped,+ preReady: DesktopPreReadyPlatform.DesktopPreReadyElectronOptions,+ }).pipe(Effect.provide(runtimeLayer));++ assert.deepEqual(result, {+ clerk: { ready: true },+ preReady: {+ linux: null,+ linuxPasswordStoreCommandLine: null,+ },+ });+ assert.deepEqual(events, ["pre-ready", "clerk"]);+ assert.equal(registerSchemesMock.mock.calls.length, 1);+ assert.equal(appendSwitchMock.mock.calls.length, 0);+ }),+ );+});diff --git a/apps/desktop/src/app/DesktopPreReadyPlatform.ts b/apps/desktop/src/app/DesktopPreReadyPlatform.tsnew file mode 100644index 000000000..7d145632d--- /dev/null+++ b/apps/desktop/src/app/DesktopPreReadyPlatform.ts@@ -0,0 +1,74 @@+// @effect-diagnostics nodeBuiltinImport:off - pre-ready Electron setup reads persisted settings synchronously before app services are available.+import * as NodeFS from "node:fs";+import * as NodeOS from "node:os";+import * as NodePath from "node:path";+import * as Context from "effect/Context";+import * as Effect from "effect/Effect";+import * as Layer from "effect/Layer";++import * as Electron from "electron";+import { HostProcessPlatform } from "@t3tools/shared/hostProcess";++import * as DesktopEarlyElectronStartup from "./DesktopEarlyElectronStartup.ts";+import * as ElectronProtocol from "../electron/ElectronProtocol.ts";++export interface DesktopPreReadyCommandLineReader {+ readonly hasSwitch: (switchName: string) => boolean;+ readonly getSwitchValue: (switchName: string) => string;+}++export function readCommandLineSwitchValue(+ commandLine: DesktopPreReadyCommandLineReader,+ switchName: string,+): string | null {+ if (!commandLine.hasSwitch(switchName)) {+ return null;+ }++ const value = commandLine.getSwitchValue(switchName).trim();+ return value.length > 0 ? value : null;+}++export const resolveEarlyLinuxElectronOptionsFromProcess =+ (): DesktopEarlyElectronStartup.EarlyLinuxElectronOptions =>+ DesktopEarlyElectronStartup.resolveEarlyLinuxElectronOptions({+ env: process.env,+ homeDirectory: NodeOS.homedir(),+ joinPath: NodePath.posix.join,+ readFileString: (path) => NodeFS.readFileSync(path, "utf8"),+ });++export class DesktopPreReadyElectronOptions extends Context.Service<+ DesktopPreReadyElectronOptions,+ {+ readonly linux: DesktopEarlyElectronStartup.EarlyLinuxElectronOptions | null;+ readonly linuxPasswordStoreCommandLine: string | null;+ }+>()("@t3tools/desktop/app/DesktopPreReadyPlatform/DesktopPreReadyElectronOptions") {}++export const make = Effect.gen(function* () {+ const platform = yield* HostProcessPlatform;+ return yield* Effect.sync((): DesktopPreReadyElectronOptions["Service"] => {+ const linuxPasswordStoreCommandLine =+ platform === "linux"+ ? readCommandLineSwitchValue(Electron.app.commandLine, "password-store")+ : null;+ const linux = platform === "linux" ? resolveEarlyLinuxElectronOptionsFromProcess() : null;++ if (linux !== null) {+ Electron.app.commandLine.appendSwitch("class", linux.linuxWmClass);+ if (linux.passwordStore !== null && linuxPasswordStoreCommandLine === null) {+ Electron.app.commandLine.appendSwitch("password-store", linux.passwordStore);+ }+ }++ return { linux, linuxPasswordStoreCommandLine };+ });+}).pipe(Effect.withSpan("desktop.electron.configureBeforeReady"));++// Keep Electron's strict pre-ready setup isolated so later runtime layers cannot+// observe app readiness before scheme privileges and command-line switches exist.+export const layer = Layer.mergeAll(+ ElectronProtocol.layerSchemePrivileges,+ Layer.effect(DesktopPreReadyElectronOptions, make),+);diff --git a/apps/desktop/src/app/DesktopStatePaths.ts b/apps/desktop/src/app/DesktopStatePaths.tsnew file mode 100644index 000000000..006dd9709--- /dev/null+++ b/apps/desktop/src/app/DesktopStatePaths.ts@@ -0,0 +1,32 @@+import * as Option from "effect/Option";++export type JoinPath = (first: string, ...segments: string[]) => string;++function normalizeConfiguredBaseDir(t3Home: Option.Option<string>): Option.Option<string> {+ if (Option.isNone(t3Home)) {+ return Option.none();+ }+ const trimmed = t3Home.value.trim();+ return trimmed.length > 0 ? Option.some(trimmed) : Option.none();+}++export function resolveDesktopBaseDir(input: {+ readonly homeDirectory: string;+ readonly joinPath: JoinPath;+ readonly t3Home: Option.Option<string>;+}): string {+ return Option.getOrElse(normalizeConfiguredBaseDir(input.t3Home), () =>+ input.joinPath(input.homeDirectory, ".t3"),+ );+}++export function resolveDesktopStateDir(input: {+ readonly baseDir: string;+ readonly isDevelopment: boolean;+ readonly joinPath: JoinPath;+ readonly t3Home: Option.Option<string>;+}): string {+ const useDevSubdir =+ input.isDevelopment && Option.isNone(normalizeConfiguredBaseDir(input.t3Home));+ return input.joinPath(input.baseDir, useDevSubdir ? "dev" : "userdata");+}diff --git a/apps/desktop/src/electron/ElectronApp.test.ts b/apps/desktop/src/electron/ElectronApp.test.tsindex ac14f56ad..e0d229497 100644--- a/apps/desktop/src/electron/ElectronApp.test.ts+++ b/apps/desktop/src/electron/ElectronApp.test.ts@@ -14,6 +14,7 @@ const {quitMock,relaunchMock,removeListenerMock,+ removeSwitchMock,setAboutPanelOptionsMock,setAppUserModelIdMock,setAsDefaultProtocolClientMock,@@ -34,6 +35,7 @@ const {quitMock: vi.fn(),relaunchMock: vi.fn(),removeListenerMock: vi.fn(),+ removeSwitchMock: vi.fn(),setAboutPanelOptionsMock: vi.fn(),setAppUserModelIdMock: vi.fn(),setAsDefaultProtocolClientMock: vi.fn(() => true),@@ -52,6 +54,7 @@ vi.mock("electron", () => ({app: {commandLine: {appendSwitch: appendSwitchMock,+ removeSwitch: removeSwitchMock,},dock: {setIcon: setDockIconMock,@@ -89,6 +92,7 @@ describe("ElectronApp", () => {quitMock.mockClear();relaunchMock.mockClear();removeListenerMock.mockClear();+ removeSwitchMock.mockClear();setPathMock.mockClear();});@@ -178,4 +182,13 @@ describe("ElectronApp", () => {]);}).pipe(Effect.provide(ElectronApp.layer)),);++ it.effect("removes command-line switches through the service", () =>+ Effect.gen(function* () {+ const electronApp = yield* ElectronApp.ElectronApp;+ yield* electronApp.removeCommandLineSwitch("password-store");++ assert.deepEqual(removeSwitchMock.mock.calls, [["password-store"]]);+ }).pipe(Effect.provide(ElectronApp.layer)),+ );});diff --git a/apps/desktop/src/electron/ElectronApp.ts b/apps/desktop/src/electron/ElectronApp.tsindex 733236171..6fb84c53b 100644--- a/apps/desktop/src/electron/ElectronApp.ts+++ b/apps/desktop/src/electron/ElectronApp.ts@@ -69,6 +69,7 @@ export class ElectronApp extends Context.Service<readonly onBeforeQuitForUpdate: (listener: () => void,) => Effect.Effect<void, never, Scope.Scope>;+ readonly removeCommandLineSwitch: (switchName: string) => Effect.Effect<void>;readonly on: <Args extends ReadonlyArray<unknown>>(eventName: string,listener: (...args: Args) => void,@@ -191,6 +192,10 @@ export const make = ElectronApp.of({Electron.autoUpdater.removeListener("before-quit-for-update", listener);}),).pipe(Effect.asVoid),+ removeCommandLineSwitch: (switchName) =>+ Effect.sync(() => {+ Electron.app.commandLine.removeSwitch(switchName);+ }),on: addScopedAppListener,});diff --git a/apps/desktop/src/electron/ElectronProtocol.ts b/apps/desktop/src/electron/ElectronProtocol.tsindex 9d5a47806..11459c9ef 100644--- a/apps/desktop/src/electron/ElectronProtocol.ts+++ b/apps/desktop/src/electron/ElectronProtocol.ts@@ -105,6 +105,38 @@ function withContentSecurityPolicy(response: Response, policy: string): Response});}+/**+ * Must run synchronously during process bootstrap, before Electron emits `ready`.+ */+export function registerDesktopSchemePrivilegesSync(): void {+ Electron.protocol.registerSchemesAsPrivileged([+ {+ scheme: DESKTOP_PRODUCTION_SCHEME,+ privileges: {+ standard: true,+ secure: true,+ supportFetchAPI: true,+ corsEnabled: true,+ },+ },+ {+ scheme: DESKTOP_DEVELOPMENT_SCHEME,+ privileges: {+ standard: true,+ secure: true,+ supportFetchAPI: true,+ corsEnabled: true,+ },+ },+ ]);+}++const registerDesktopSchemePrivileges = Effect.sync(registerDesktopSchemePrivilegesSync).pipe(+ Effect.withSpan("desktop.electron.protocol.registerSchemePrivileges"),+);++export const layerSchemePrivileges = Layer.effectDiscard(registerDesktopSchemePrivileges);+async function proxyRequest(request: Request,targetOrigin: URL,diff --git a/apps/desktop/src/electron/ElectronSafeStorage.ts b/apps/desktop/src/electron/ElectronSafeStorage.tsindex 76162c164..b9dab7105 100644--- a/apps/desktop/src/electron/ElectronSafeStorage.ts+++ b/apps/desktop/src/electron/ElectronSafeStorage.ts@@ -1,9 +1,11 @@import * as Context from "effect/Context";import * as Effect from "effect/Effect";import * as Layer from "effect/Layer";+import * as Option from "effect/Option";import * as Schema from "effect/Schema";import * as Electron from "electron";+import { HostProcessPlatform } from "@t3tools/shared/hostProcess";const electronSafeStorageErrorFields = {cause: Schema.Defect(),@@ -60,24 +62,39 @@ export class ElectronSafeStorage extends Context.Service<readonly decryptString: (value: Uint8Array,) => Effect.Effect<string, ElectronSafeStorageDecryptError>;+ readonly selectedStorageBackend: Effect.Effect<Option.Option<string>>;}>()("@t3tools/desktop/electron/ElectronSafeStorage") {}-export const make = ElectronSafeStorage.of({- isEncryptionAvailable: Effect.try({- try: () => Electron.safeStorage.isEncryptionAvailable(),- catch: (cause) => new ElectronSafeStorageAvailabilityError({ cause }),- }),- encryptString: (value) =>- Effect.try({- try: () => Electron.safeStorage.encryptString(value),- catch: (cause) => new ElectronSafeStorageEncryptError({ cause }),+export const make = Effect.gen(function* () {+ const platform = yield* HostProcessPlatform;++ return ElectronSafeStorage.of({+ isEncryptionAvailable: Effect.try({+ try: () => Electron.safeStorage.isEncryptionAvailable(),+ catch: (cause) => new ElectronSafeStorageAvailabilityError({ cause }),}),- decryptString: (value) =>- Effect.try({- try: () => Electron.safeStorage.decryptString(Buffer.from(value)),- catch: (cause) => new ElectronSafeStorageDecryptError({ cause }),+ encryptString: (value) =>+ Effect.try({+ try: () => Electron.safeStorage.encryptString(value),+ catch: (cause) => new ElectronSafeStorageEncryptError({ cause }),+ }),+ decryptString: (value) =>+ Effect.try({+ try: () => Electron.safeStorage.decryptString(Buffer.from(value)),+ catch: (cause) => new ElectronSafeStorageDecryptError({ cause }),+ }),+ selectedStorageBackend: Effect.sync(() => {+ if (platform !== "linux") {+ return Option.none();+ }+ try {+ return Option.fromNullishOr(Electron.safeStorage.getSelectedStorageBackend());+ } catch {+ return Option.none();+ }}),+ });});-export const layer = Layer.succeed(ElectronSafeStorage, make);+export const layer = Layer.effect(ElectronSafeStorage, make);diff --git a/apps/desktop/src/linuxSecretStorage.test.ts b/apps/desktop/src/linuxSecretStorage.test.tsnew file mode 100644index 000000000..a91790200--- /dev/null+++ b/apps/desktop/src/linuxSecretStorage.test.ts@@ -0,0 +1,203 @@+import { describe, expect, it } from "vite-plus/test";++import {+ normalizeLinuxPasswordStorePreference,+ resolveLinuxPasswordStoreSwitch,+ resolveLinuxSecretStorageUnavailableMessage,+} from "./linuxSecretStorage.ts";++const autoSwitch = (env: NodeJS.ProcessEnv) =>+ resolveLinuxPasswordStoreSwitch({ preference: "auto", env });++describe("linuxSecretStorage", () => {+ it("preserves explicit supported password-store preferences", () => {+ expect(normalizeLinuxPasswordStorePreference("gnome-libsecret")).toBe("gnome-libsecret");+ expect(normalizeLinuxPasswordStorePreference("kwallet")).toBe("kwallet");+ expect(normalizeLinuxPasswordStorePreference("kwallet5")).toBe("kwallet5");+ expect(normalizeLinuxPasswordStorePreference("kwallet6")).toBe("kwallet6");+ });++ it("falls back to auto for missing or unsupported preferences", () => {+ expect(normalizeLinuxPasswordStorePreference(undefined)).toBe("auto");+ expect(normalizeLinuxPasswordStorePreference("basic")).toBe("auto");+ });++ it("uses explicit preferences instead of the auto heuristic", () => {+ for (const preference of ["gnome-libsecret", "kwallet", "kwallet5", "kwallet6"] as const) {+ expect(+ resolveLinuxPasswordStoreSwitch({ preference, env: { XDG_CURRENT_DESKTOP: "niri" } }),+ ).toBe(preference);+ // An explicit preference also wins where auto would have stayed out of the way.+ expect(+ resolveLinuxPasswordStoreSwitch({ preference, env: { XDG_CURRENT_DESKTOP: "KDE" } }),+ ).toBe(preference);+ }+ });++ it("leaves canonical KDE sessions to Electron's own wallet selection", () => {+ expect(autoSwitch({ XDG_CURRENT_DESKTOP: "KDE" })).toBeNull();+ expect(autoSwitch({ XDG_CURRENT_DESKTOP: "KDE", KDE_SESSION_VERSION: "6" })).toBeNull();+ expect(autoSwitch({ XDG_CURRENT_DESKTOP: "KDE", KDE_SESSION_VERSION: "5" })).toBeNull();+ expect(autoSwitch({ XDG_CURRENT_DESKTOP: "KDE:plasma" })).toBeNull();+ });++ it("does not force a password-store for desktops Electron already recognizes", () => {+ expect(autoSwitch({ XDG_CURRENT_DESKTOP: "GNOME" })).toBeNull();+ for (const desktop of ["Deepin", "Pantheon", "UKUI", "Unity", "X-Cinnamon", "XFCE"]) {+ expect(autoSwitch({ XDG_CURRENT_DESKTOP: desktop })).toBeNull();+ }+ });++ it("recognizes a known desktop later in a colon-separated XDG_CURRENT_DESKTOP list", () => {+ expect(autoSwitch({ XDG_CURRENT_DESKTOP: "niri:GNOME" })).toBeNull();+ expect(autoSwitch({ XDG_CURRENT_DESKTOP: "ubuntu:GNOME" })).toBeNull();+ });++ it("forces gnome-libsecret for unrecognized Linux desktop sessions", () => {+ expect(autoSwitch({ XDG_CURRENT_DESKTOP: "niri" })).toBe("gnome-libsecret");+ expect(autoSwitch({ XDG_CURRENT_DESKTOP: "Hyprland" })).toBe("gnome-libsecret");+ expect(autoSwitch({})).toBe("gnome-libsecret");+ });++ it("forces gnome-libsecret for desktops Electron recognizes but leaves on basic text", () => {+ expect(autoSwitch({ XDG_CURRENT_DESKTOP: "LXQt" })).toBe("gnome-libsecret");+ // Chromium stops at the first recognized value, so a later name cannot rescue the session.+ expect(autoSwitch({ XDG_CURRENT_DESKTOP: "LXQt:GNOME" })).toBe("gnome-libsecret");+ expect(autoSwitch({ XDG_CURRENT_DESKTOP: "LXQt:KDE" })).toBe("gnome-libsecret");+ expect(autoSwitch({ XDG_CURRENT_DESKTOP: "LXQt:plasma" })).toBe("gnome-libsecret");+ });++ it("does not treat lowercase desktop names as ones Electron recognizes", () => {+ // Chromium matches these case-sensitively, so lowercase spellings reach basic text.+ expect(autoSwitch({ XDG_CURRENT_DESKTOP: "gnome" })).toBe("gnome-libsecret");+ expect(autoSwitch({ XDG_CURRENT_DESKTOP: "xfce" })).toBe("gnome-libsecret");+ expect(autoSwitch({ XDG_CURRENT_DESKTOP: "kde", KDE_SESSION_VERSION: "6" })).toBe(+ "gnome-libsecret",+ );+ });++ it("overrides KDE sessions identified only by legacy variables", () => {+ // Chromium reaches KWallet4 for some of these, such as DESKTOP_SESSION=kde with a version, and+ // basic text for the rest. Either way these are the variables a previous session leaves behind,+ // so they are treated as unproven and forced to a real keyring rather than a guessed wallet.+ expect(autoSwitch({ XDG_CURRENT_DESKTOP: "plasma" })).toBe("gnome-libsecret");+ for (const session of [+ "kde",+ "kde-plasma",+ "kde4",+ "plasma",+ "plasmawayland",+ "plasmawayland-dev",+ "plasmax11",+ "plasmax11-dev",+ ]) {+ expect(autoSwitch({ DESKTOP_SESSION: session })).toBe("gnome-libsecret");+ expect(autoSwitch({ XDG_SESSION_DESKTOP: session })).toBe("gnome-libsecret");+ expect(autoSwitch({ GDMSESSION: session })).toBe("gnome-libsecret");+ }+ expect(autoSwitch({ DESKTOP_SESSION: "kde", KDE_SESSION_VERSION: "6" })).toBe(+ "gnome-libsecret",+ );+ expect(autoSwitch({ KDE_SESSION_VERSION: "6" })).toBe("gnome-libsecret");+ expect(autoSwitch({ KDE_FULL_SESSION: "true", KDE_SESSION_VERSION: "6" })).toBe(+ "gnome-libsecret",+ );+ });++ it("ignores stale session hints when XDG_CURRENT_DESKTOP is authoritative", () => {+ expect(+ autoSwitch({ XDG_CURRENT_DESKTOP: "niri", DESKTOP_SESSION: "gnome", GDMSESSION: "gnome" }),+ ).toBe("gnome-libsecret");+ // A previous KDE session left these behind; the compositor running now is not KDE.+ expect(autoSwitch({ XDG_CURRENT_DESKTOP: "niri", KDE_SESSION_VERSION: "6" })).toBe(+ "gnome-libsecret",+ );+ expect(autoSwitch({ XDG_CURRENT_DESKTOP: "niri", XDG_SESSION_DESKTOP: "GNOME" })).toBe(+ "gnome-libsecret",+ );+ expect(autoSwitch({ XDG_CURRENT_DESKTOP: "niri:plasma" })).toBe("gnome-libsecret");+ expect(+ autoSwitch({+ XDG_CURRENT_DESKTOP: "Hyprland",+ XDG_SESSION_DESKTOP: "KDE",+ KDE_SESSION_VERSION: "6",+ }),+ ).toBe("gnome-libsecret");+ });++ it("uses GNOME Keyring remediation for libsecret and unknown backends", () => {+ expect(+ resolveLinuxSecretStorageUnavailableMessage({+ configuredPreference: "auto",+ selectedBackend: "gnome_libsecret",+ env: { XDG_CURRENT_DESKTOP: "niri" },+ }),+ ).toContain("GNOME Keyring");+ });++ it("prefers explicit libsecret selection over KDE desktop heuristics", () => {+ expect(+ resolveLinuxSecretStorageUnavailableMessage({+ configuredPreference: "gnome-libsecret",+ selectedBackend: "unknown",+ env: { XDG_CURRENT_DESKTOP: "KDE" },+ }),+ ).toContain("GNOME Keyring");+ expect(+ resolveLinuxSecretStorageUnavailableMessage({+ configuredPreference: "auto",+ selectedBackend: "gnome_libsecret",+ env: { XDG_CURRENT_DESKTOP: "KDE" },+ }),+ ).toContain("GNOME Keyring");+ });++ it("prefers explicit KWallet preference over selected gnome-libsecret backend", () => {+ expect(+ resolveLinuxSecretStorageUnavailableMessage({+ configuredPreference: "kwallet6",+ selectedBackend: "gnome_libsecret",+ env: { XDG_CURRENT_DESKTOP: "niri" },+ }),+ ).toContain("KWallet");+ expect(+ resolveLinuxSecretStorageUnavailableMessage({+ configuredPreference: "kwallet",+ selectedBackend: "gnome-libsecret",+ env: {},+ }),+ ).toContain("KWallet");+ });++ it("uses KWallet remediation wording for KDE-looking sessions", () => {+ expect(+ resolveLinuxSecretStorageUnavailableMessage({+ configuredPreference: "auto",+ selectedBackend: "kwallet6",+ env: {},+ }),+ ).toContain("KWallet");+ expect(+ resolveLinuxSecretStorageUnavailableMessage({+ configuredPreference: "auto",+ selectedBackend: "unknown",+ env: { XDG_CURRENT_DESKTOP: "KDE" },+ }),+ ).toContain("KWallet");+ expect(+ resolveLinuxSecretStorageUnavailableMessage({+ configuredPreference: "auto",+ selectedBackend: "unknown",+ env: { DESKTOP_SESSION: "plasmawayland" },+ }),+ ).toContain("KWallet");+ // A desktop name outranks a bare KDE marker when choosing the wording.+ expect(+ resolveLinuxSecretStorageUnavailableMessage({+ configuredPreference: "auto",+ selectedBackend: "unknown",+ env: { GDMSESSION: "gnome", KDE_FULL_SESSION: "true" },+ }),+ ).toContain("GNOME Keyring");+ });+});diff --git a/apps/desktop/src/linuxSecretStorage.ts b/apps/desktop/src/linuxSecretStorage.tsnew file mode 100644index 000000000..fe3e21ead--- /dev/null+++ b/apps/desktop/src/linuxSecretStorage.ts@@ -0,0 +1,178 @@+export type LinuxPasswordStorePreference =+ | "auto"+ | "gnome-libsecret"+ | "kwallet"+ | "kwallet5"+ | "kwallet6";+export type LinuxPasswordStoreSwitch = Exclude<LinuxPasswordStorePreference, "auto">;++export const DEFAULT_LINUX_PASSWORD_STORE: LinuxPasswordStorePreference = "auto";++// Chromium matches XDG_CURRENT_DESKTOP values case-sensitively and returns on the first value it+// recognizes, so these stay exact literals and are scanned in order. Omitting a real desktop fails+// safe: we force gnome-libsecret, which is the backend Chromium selects for all of these anyway.+const ELECTRON_LIBSECRET_DESKTOPS = new Set([+ "Deepin",+ "GNOME",+ "Pantheon",+ "UKUI",+ "Unity",+ "X-Cinnamon",+ "XFCE",+]);+// Chromium selects a KWallet generation for KDE from KDE_SESSION_VERSION, so it needs no help.+const ELECTRON_KDE_DESKTOP = "KDE";+// Chromium recognizes LXQt and still selects basic text for it, so it does need a forced backend.+const ELECTRON_UNPROTECTED_DESKTOPS = new Set(["LXQt"]);++const KDE_NAME_PREFIXES = ["kde", "plasma"];+const NEGATIVE_FLAG_VALUES = new Set(["0", "false", "no", "off"]);++export function normalizeLinuxPasswordStorePreference(+ value: unknown,+): LinuxPasswordStorePreference {+ return value === "gnome-libsecret" ||+ value === "kwallet" ||+ value === "kwallet5" ||+ value === "kwallet6"+ ? value+ : DEFAULT_LINUX_PASSWORD_STORE;+}++// Auto mode asks one question: will Electron select a real keyring on its own? If so, stay out of+// the way, which is how canonical KDE sessions keep the KWallet generation Chromium picks for them.+// Otherwise force gnome-libsecret, because the alternative is basic text, which is barely+// encryption at all. Forcing never guesses a KWallet generation; a KDE session that needs a+// specific one sets linuxPasswordStore explicitly.+export function resolveLinuxPasswordStoreSwitch(input: {+ readonly preference: LinuxPasswordStorePreference;+ readonly env: NodeJS.ProcessEnv;+}): LinuxPasswordStoreSwitch | null {+ if (input.preference !== "auto") {+ return input.preference;+ }++ return electronSelectsProtectedBackend(input.env) ? null : "gnome-libsecret";+}++// Only an exact XDG_CURRENT_DESKTOP literal proves Electron will protect the session. Chromium can+// also reach a real backend through DESKTOP_SESSION and the legacy KDE markers, but those are the+// variables a previous session leaves behind, and trusting them is what let stale hints suppress+// the forced backend before. Forcing where Chromium would have chosen libsecret is harmless, since+// it lands on the same backend.+function electronSelectsProtectedBackend(env: NodeJS.ProcessEnv): boolean {+ for (const name of splitDesktopNameList(env.XDG_CURRENT_DESKTOP)) {+ const trimmed = name.trim();+ if (trimmed.length === 0) {+ continue;+ }+ if (trimmed === ELECTRON_KDE_DESKTOP || ELECTRON_LIBSECRET_DESKTOPS.has(trimmed)) {+ return true;+ }+ if (ELECTRON_UNPROTECTED_DESKTOPS.has(trimmed)) {+ return false;+ }+ }++ return false;+}++export function resolveLinuxSecretStorageUnavailableMessage(input: {+ readonly configuredPreference: LinuxPasswordStorePreference;+ readonly selectedBackend: string | null;+ readonly env: NodeJS.ProcessEnv;+}): string {+ if (input.configuredPreference === "gnome-libsecret") {+ return getGnomeKeyringRemediationMessage();+ }++ if (+ input.configuredPreference === "kwallet" ||+ input.configuredPreference === "kwallet5" ||+ input.configuredPreference === "kwallet6"+ ) {+ return getKWalletRemediationMessage();+ }++ const backend = normalizeSelectedStorageBackend(input.selectedBackend);+ if (backend === "gnome-libsecret") {+ return getGnomeKeyringRemediationMessage();+ }++ if (+ backend === "kwallet" ||+ backend === "kwallet5" ||+ backend === "kwallet6" ||+ looksLikeKdeSession(input.env)+ ) {+ return getKWalletRemediationMessage();+ }++ return getGnomeKeyringRemediationMessage();+}++function getGnomeKeyringRemediationMessage(): string {+ return "T3 Code could not access GNOME Keyring to save this environment credential. Install and start GNOME Keyring, then restart T3 Code.";+}++function getKWalletRemediationMessage(): string {+ return "T3 Code could not access KWallet to save this environment credential. Enable the KDE wallet subsystem in System Settings, then restart T3 Code.";+}++// Advisory only: this picks between the GNOME Keyring and KWallet wording in the failure notice. It+// never decides which backend to select, so a loose match costs a user slightly wrong instructions+// rather than an unprotected credential store.+function looksLikeKdeSession(env: NodeJS.ProcessEnv): boolean {+ const currentDesktopNames = nonEmptyDesktopNames(env.XDG_CURRENT_DESKTOP);+ if (currentDesktopNames.length > 0) {+ return currentDesktopNames.some(isKdeDesktopName);+ }++ const legacyNames = legacyDesktopNames(env);+ if (legacyNames.length > 0) {+ return legacyNames.some(isKdeDesktopName);+ }++ return isSet(env.KDE_SESSION_VERSION) || isAffirmativeFlag(env.KDE_FULL_SESSION);+}++function isKdeDesktopName(name: string): boolean {+ return KDE_NAME_PREFIXES.some((prefix) => name.startsWith(prefix));+}++function legacyDesktopNames(env: NodeJS.ProcessEnv): string[] {+ return [env.XDG_SESSION_DESKTOP, env.DESKTOP_SESSION, env.GDMSESSION].flatMap((entry) => {+ const normalized = normalizeDesktopName(entry);+ return normalized ? [normalized] : [];+ });+}++function nonEmptyDesktopNames(value: string | undefined): string[] {+ return splitDesktopNameList(value).flatMap((entry) => {+ const normalized = normalizeDesktopName(entry);+ return normalized ? [normalized] : [];+ });+}++function isSet(value: string | undefined): boolean {+ return Boolean(value?.trim());+}++function isAffirmativeFlag(value: string | undefined): boolean {+ const normalized = value?.trim().toLowerCase();+ return normalized ? !NEGATIVE_FLAG_VALUES.has(normalized) : false;+}++function splitDesktopNameList(value: string | undefined): string[] {+ return value?.split(":") ?? [];+}++function normalizeDesktopName(value: string | undefined): string | null {+ const normalized = value?.trim().toLowerCase();+ return normalized && normalized.length > 0 ? normalized : null;+}++function normalizeSelectedStorageBackend(value: string | null): string | null {+ const normalized = value?.trim().toLowerCase().replace(/_/gu, "-");+ return normalized && normalized.length > 0 ? normalized : null;+}diff --git a/apps/desktop/src/main.ts b/apps/desktop/src/main.tsindex 933a7e4d8..0616184ec 100644--- a/apps/desktop/src/main.ts+++ b/apps/desktop/src/main.ts@@ -50,6 +50,7 @@ import * as DesktopServerExposure from "./backend/DesktopServerExposure.ts";import * as DesktopClientSettings from "./settings/DesktopClientSettings.ts";import * as DesktopSavedEnvironments from "./settings/DesktopSavedEnvironments.ts";import * as DesktopAppSettings from "./settings/DesktopAppSettings.ts";+import * as DesktopPreReadyPlatform from "./app/DesktopPreReadyPlatform.ts";import * as DesktopShellEnvironment from "./shell/DesktopShellEnvironment.ts";import * as DesktopSshEnvironment from "./ssh/DesktopSshEnvironment.ts";import * as DesktopSshPasswordPrompts from "./ssh/DesktopSshPasswordPrompts.ts";@@ -197,16 +198,20 @@ const desktopClerkLayer = DesktopClerk.layer.pipe(Layer.provideMerge(ElectronApp.layer),);+const desktopApplicationRuntimeLayer = desktopApplicationLayer.pipe(+ Layer.provideMerge(NodeServices.layer),+ Layer.provideMerge(NodeHttpClient.layerUndici),+ Layer.provideMerge(NetService.layer),+ Layer.provideMerge(electronLayer),+);++// Acquire strict pre-ready setup before Clerk, whose userData resolution can+// yield and let Electron emit ready.const desktopRuntimeLayer = desktopClerkLayer.pipe(Layer.flatMap((clerkContext) =>- desktopApplicationLayer.pipe(- Layer.provideMerge(Layer.succeedContext(clerkContext)),- Layer.provideMerge(NodeServices.layer),- Layer.provideMerge(NodeHttpClient.layerUndici),- Layer.provideMerge(NetService.layer),- Layer.provideMerge(electronLayer),- ),+ desktopApplicationRuntimeLayer.pipe(Layer.provideMerge(Layer.succeedContext(clerkContext))),),+ Layer.provideMerge(DesktopPreReadyPlatform.layer),);DesktopApp.program.pipe(Effect.provide(desktopRuntimeLayer), NodeRuntime.runMain);diff --git a/apps/desktop/src/settings/DesktopAppSettings.test.ts b/apps/desktop/src/settings/DesktopAppSettings.test.tsindex 3878b0e36..64c59749a 100644--- a/apps/desktop/src/settings/DesktopAppSettings.test.ts+++ b/apps/desktop/src/settings/DesktopAppSettings.test.ts@@ -11,6 +11,9 @@ import * as DesktopEnvironment from "../app/DesktopEnvironment.ts";import * as DesktopAppSettings from "./DesktopAppSettings.ts";const DesktopSettingsPatch = Schema.Struct({+ linuxPasswordStore: Schema.optionalKey(+ Schema.Literals(["auto", "gnome-libsecret", "kwallet", "kwallet5", "kwallet6"]),+ ),mainWindowBounds: Schema.optionalKey(Schema.NullOr(Schema.Struct({@@ -102,6 +105,7 @@ describe("DesktopSettings", () => {assert.deepEqual(DesktopAppSettings.resolveDefaultDesktopSettings("0.0.17-nightly.20260415.1"),{+ linuxPasswordStore: "auto",mainWindowBounds: null,mainWindowMaximized: false,serverExposureMode: "local-only",@@ -121,6 +125,7 @@ describe("DesktopSettings", () => {Effect.gen(function* () {const settings = yield* DesktopAppSettings.DesktopAppSettings;yield* writeSettingsPatch({+ linuxPasswordStore: "gnome-libsecret",serverExposureMode: "network-accessible",tailscaleServeEnabled: true,tailscaleServePort: 8443,@@ -129,6 +134,7 @@ describe("DesktopSettings", () => {});assert.deepEqual(yield* settings.load, {+ linuxPasswordStore: "gnome-libsecret",mainWindowBounds: null,mainWindowMaximized: false,serverExposureMode: "network-accessible",@@ -235,6 +241,7 @@ describe("DesktopSettings", () => {);assert.deepEqual(yield* settings.load, {+ linuxPasswordStore: "auto",mainWindowBounds: { x: 120, y: 80, width: 1280, height: 900 },mainWindowMaximized: false,serverExposureMode: "network-accessible",@@ -268,6 +275,44 @@ describe("DesktopSettings", () => {),);+ it.effect(+ "normalizes unsupported linux password-store values without dropping other settings",+ () =>+ withSettings(+ Effect.gen(function* () {+ const environment = yield* DesktopEnvironment.DesktopEnvironment;+ const fileSystem = yield* FileSystem.FileSystem;+ const settings = yield* DesktopAppSettings.DesktopAppSettings;+ yield* fileSystem.makeDirectory(environment.stateDir, { recursive: true });+ yield* fileSystem.writeFileString(+ environment.desktopSettingsPath,+ `{+ "linuxPasswordStore": "unsupported-store",+ "serverExposureMode": "network-accessible",+ "tailscaleServeEnabled": true,+ "tailscaleServePort": 8443,+ "updateChannel": "nightly",+ "updateChannelConfiguredByUser": true+ }\n`,+ );++ assert.deepEqual(yield* settings.load, {+ linuxPasswordStore: "auto",+ mainWindowBounds: null,+ mainWindowMaximized: false,+ serverExposureMode: "network-accessible",+ tailscaleServeEnabled: true,+ tailscaleServePort: 8443,+ updateChannel: "nightly",+ updateChannelConfiguredByUser: true,+ wslBackendEnabled: false,+ wslOnly: false,+ wslDistro: null,+ } satisfies DesktopAppSettings.DesktopSettings);+ }),+ ),+ );+it.effect("persists sparse desktop settings documents", () =>withSettings(Effect.gen(function* () {@@ -300,6 +345,7 @@ describe("DesktopSettings", () => {});assert.deepEqual(yield* settings.load, {+ linuxPasswordStore: "auto",mainWindowBounds: null,mainWindowMaximized: false,serverExposureMode: "local-only",@@ -327,6 +373,7 @@ describe("DesktopSettings", () => {});assert.deepEqual(yield* settings.load, {+ linuxPasswordStore: "auto",mainWindowBounds: null,mainWindowMaximized: false,serverExposureMode: "local-only",@@ -353,6 +400,7 @@ describe("DesktopSettings", () => {});assert.deepEqual(yield* settings.load, {+ linuxPasswordStore: "auto",mainWindowBounds: null,mainWindowMaximized: false,serverExposureMode: "local-only",diff --git a/apps/desktop/src/settings/DesktopAppSettings.ts b/apps/desktop/src/settings/DesktopAppSettings.tsindex 466c9a9b5..aefc67525 100644--- a/apps/desktop/src/settings/DesktopAppSettings.ts+++ b/apps/desktop/src/settings/DesktopAppSettings.ts@@ -16,10 +16,16 @@ import * as Schema from "effect/Schema";import * as SynchronizedRef from "effect/SynchronizedRef";import * as DesktopEnvironment from "../app/DesktopEnvironment.ts";+import {+ DEFAULT_LINUX_PASSWORD_STORE,+ normalizeLinuxPasswordStorePreference,+ type LinuxPasswordStorePreference,+} from "../linuxSecretStorage.ts";import { resolveDefaultDesktopUpdateChannel } from "../updates/updateChannels.ts";import { isValidDistroName } from "../wsl/wslPathParsing.ts";export interface DesktopSettings {+ readonly linuxPasswordStore: LinuxPasswordStorePreference;readonly mainWindowBounds: DesktopWindowBounds | null;readonly mainWindowMaximized: boolean;readonly serverExposureMode: DesktopServerExposureMode;@@ -67,6 +73,7 @@ export const DEFAULT_MAIN_WINDOW_SIZE = {} as const;export const DEFAULT_DESKTOP_SETTINGS: DesktopSettings = {+ linuxPasswordStore: DEFAULT_LINUX_PASSWORD_STORE,mainWindowBounds: null,mainWindowMaximized: false,serverExposureMode: "local-only",@@ -87,6 +94,7 @@ const DesktopWindowBoundsDocument = Schema.Struct({});const DesktopSettingsDocument = Schema.Struct({+ linuxPasswordStore: Schema.optionalKey(Schema.Unknown),mainWindowBounds: Schema.optionalKey(Schema.NullOr(DesktopWindowBoundsDocument)),mainWindowMaximized: Schema.optionalKey(Schema.Boolean),serverExposureMode: Schema.optionalKey(DesktopServerExposureModeSchema),@@ -216,6 +224,7 @@ function normalizeDesktopSettingsDocument((parsed.wslBackendEnabled === undefined && parsed.wslMode === "wsl");return {+ linuxPasswordStore: normalizeLinuxPasswordStorePreference(parsed.linuxPasswordStore),mainWindowBounds,mainWindowMaximized: mainWindowBounds !== null && parsed.mainWindowMaximized === true,serverExposureMode:@@ -238,6 +247,9 @@ function toDesktopSettingsDocument(): DesktopSettingsDocument {const document: Mutable<DesktopSettingsDocument> = {};+ if (settings.linuxPasswordStore !== defaults.linuxPasswordStore) {+ document.linuxPasswordStore = settings.linuxPasswordStore;+ }if (settings.mainWindowBounds !== null) {document.mainWindowBounds = settings.mainWindowBounds;}diff --git a/apps/desktop/src/settings/DesktopSavedEnvironments.test.ts b/apps/desktop/src/settings/DesktopSavedEnvironments.test.tsindex ec70308b3..05b1ca144 100644--- a/apps/desktop/src/settings/DesktopSavedEnvironments.test.ts+++ b/apps/desktop/src/settings/DesktopSavedEnvironments.test.ts@@ -86,6 +86,7 @@ function makeSafeStorageLayer(input: {}return Effect.succeed(decoded.slice("enc:".length));},+ selectedStorageBackend: Effect.succeed(Option.none()),} satisfies ElectronSafeStorage.ElectronSafeStorage["Service"]);}diff --git a/apps/desktop/src/shell/DesktopShellEnvironment.test.ts b/apps/desktop/src/shell/DesktopShellEnvironment.test.tsindex 7ec0ab80a..b8c66e9b7 100644--- a/apps/desktop/src/shell/DesktopShellEnvironment.test.ts+++ b/apps/desktop/src/shell/DesktopShellEnvironment.test.ts@@ -1,3 +1,4 @@+import * as NodeServices from "@effect/platform-node/NodeServices";import { assert, describe, it } from "@effect/vitest";import * as Effect from "effect/Effect";import * as Layer from "effect/Layer";@@ -90,7 +91,7 @@ function runShellEnvironment(input: {}).pipe(Effect.provide(DesktopShellEnvironment.layer.pipe(- Layer.provide(Layer.mergeAll(environmentLayer, spawnerLayer)),+ Layer.provide(Layer.mergeAll(environmentLayer, NodeServices.layer, spawnerLayer)),),),);@@ -243,6 +244,65 @@ describe("DesktopShellEnvironment", () => {}),);+ it.effect("prefers login-shell desktop session hints over inherited values on linux", () =>+ Effect.gen(function* () {+ const env: NodeJS.ProcessEnv = {+ SHELL: "/bin/zsh",+ PATH: "/usr/bin",+ XDG_CURRENT_DESKTOP: "wrong-launcher",+ XDG_SESSION_DESKTOP: "wrong-launcher",+ };++ yield* runShellEnvironment({+ env,+ platform: "linux",+ handler: () =>+ envOutput({+ PATH: "/home/linuxbrew/.linuxbrew/bin:/usr/bin",+ XDG_CURRENT_DESKTOP: "KDE",+ XDG_SESSION_DESKTOP: "KDE",+ XDG_SESSION_TYPE: "wayland",+ }),+ });++ assert.equal(env.XDG_CURRENT_DESKTOP, "KDE");+ assert.equal(env.XDG_SESSION_DESKTOP, "KDE");+ assert.equal(env.XDG_SESSION_TYPE, "wayland");+ }),+ );++ it.effect("overrides stale dbus session addresses from the login shell", () =>+ Effect.gen(function* () {+ const env: NodeJS.ProcessEnv = {+ SHELL: "/bin/zsh",+ PATH: "/usr/bin",+ DBUS_SESSION_BUS_ADDRESS: "unix:path=/tmp/stale-bus",+ };++ yield* runShellEnvironment({+ env,+ platform: "linux",+ handler: () =>+ envOutput({+ PATH: "/usr/bin",+ DBUS_SESSION_BUS_ADDRESS: "unix:path=/run/user/1000/bus",+ }),+ });++ assert.equal(env.DBUS_SESSION_BUS_ADDRESS, "unix:path=/run/user/1000/bus");+ }),+ );++ it("resolves dbus runtime dir candidates with existence checks", () => {+ const busPath = DesktopShellEnvironment.resolveDefaultLinuxDbusSessionBusAddress({+ env: { XDG_RUNTIME_DIR: "/tmp/stale-runtime" },+ uid: 1000,+ exists: (path) => path === "/run/user/1000/bus",+ });++ assert.equal(busPath, "unix:path=/run/user/1000/bus");+ });+it.effect("logs command failures with safe probe context and the exact cause", () => {const env: NodeJS.ProcessEnv = {SHELL: "/bin/bash",diff --git a/apps/desktop/src/shell/DesktopShellEnvironment.ts b/apps/desktop/src/shell/DesktopShellEnvironment.tsindex 8219f18b7..5627eec54 100644--- a/apps/desktop/src/shell/DesktopShellEnvironment.ts+++ b/apps/desktop/src/shell/DesktopShellEnvironment.ts@@ -1,6 +1,7 @@import * as Context from "effect/Context";import * as Duration from "effect/Duration";import * as Effect from "effect/Effect";+import * as FileSystem from "effect/FileSystem";import * as Layer from "effect/Layer";import * as Option from "effect/Option";import * as Schema from "effect/Schema";@@ -68,12 +69,19 @@ export class DesktopShellEnvironment extends Context.Service<const LOGIN_SHELL_ENV_NAMES = ["PATH",+ "DBUS_SESSION_BUS_ADDRESS",+ "DISPLAY","SSH_AUTH_SOCK","HOMEBREW_PREFIX","HOMEBREW_CELLAR","HOMEBREW_REPOSITORY","XDG_CONFIG_HOME",+ "XDG_CURRENT_DESKTOP","XDG_DATA_HOME",+ "XDG_RUNTIME_DIR",+ "XDG_SESSION_DESKTOP",+ "XDG_SESSION_TYPE",+ "WAYLAND_DISPLAY",] as const;const WINDOWS_PROFILE_ENV_NAMES = ["PATH", "FNM_DIR", "FNM_MULTISHELL_PATH"] as const;const WINDOWS_SHELL_CANDIDATES = ["pwsh.exe", "powershell.exe"] as const;@@ -92,6 +100,47 @@ const pathDelimiter = (platform: NodeJS.Platform) => (platform === "win32" ? ";"const readEnvPath = (env: NodeJS.ProcessEnv): Option.Option<string> =>trimNonEmpty(env.PATH ?? env.Path ?? env.path);+const normalizeRuntimeDir = (value: string): string => value.replace(/\/+$/u, "");++const linuxRuntimeDirCandidates = (+ env: NodeJS.ProcessEnv,+ uid: number | undefined,+): ReadonlyArray<string> => {+ const candidates: string[] = [];+ const fromEnv = trimNonEmpty(env.XDG_RUNTIME_DIR);+ if (Option.isSome(fromEnv)) {+ candidates.push(normalizeRuntimeDir(fromEnv.value));+ }+ if (uid !== undefined) {+ candidates.push(`/run/user/${uid}`);+ }+ return candidates.filter((candidate) => candidate.length > 0);+};++function resolveDefaultLinuxDbusSessionBusPath(input: {+ readonly env: NodeJS.ProcessEnv;+ readonly uid: number | undefined;+ readonly exists?: (path: string) => boolean;+}): string | null {+ for (const runtimeDir of linuxRuntimeDirCandidates(input.env, input.uid)) {+ const busPath = `${runtimeDir}/bus`;+ if (input.exists === undefined || input.exists(busPath)) {+ return busPath;+ }+ }++ return null;+}++export function resolveDefaultLinuxDbusSessionBusAddress(input: {+ readonly env: NodeJS.ProcessEnv;+ readonly exists: (path: string) => boolean;+ readonly uid: number | undefined;+}): string | null {+ const busPath = resolveDefaultLinuxDbusSessionBusPath(input);+ return busPath !== null && input.exists(busPath) ? `unix:path=${busPath}` : null;+}+const pathComparisonKey = (entry: string, platform: NodeJS.Platform) => {const normalized = entry.trim().replace(/^"+|"+$/g, "");return platform === "win32" ? normalized.toLowerCase() : normalized;@@ -356,7 +405,12 @@ const installWindowsEnvironment = Effect.fn("desktop.shellEnvironment.installWinconst installPosixEnvironment = Effect.fn("desktop.shellEnvironment.installPosixEnvironment")(function* (config: ShellEnvironmentConfig,- ): Effect.fn.Return<void, never, ChildProcessSpawner.ChildProcessSpawner> {+ ): Effect.fn.Return<+ void,+ never,+ ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem+ > {+ const fileSystem = yield* FileSystem.FileSystem;const shellEnvironment: EnvironmentPatch = {};for (const shell of listLoginShellCandidates(config)) {@@ -383,23 +437,54 @@ const installPosixEnvironment = Effect.fn("desktop.shellEnvironment.installPosixconfig.env.SSH_AUTH_SOCK = shellEnvironment.SSH_AUTH_SOCK;}+ const shellPreferredEnvNames = [+ "DBUS_SESSION_BUS_ADDRESS",+ "XDG_CURRENT_DESKTOP",+ "XDG_SESSION_DESKTOP",+ "XDG_SESSION_TYPE",+ ] as const;+ for (const name of shellPreferredEnvNames) {+ if (shellEnvironment[name]) {+ config.env[name] = shellEnvironment[name];+ }+ }+for (const name of [+ "DISPLAY","HOMEBREW_PREFIX","HOMEBREW_CELLAR","HOMEBREW_REPOSITORY","XDG_CONFIG_HOME","XDG_DATA_HOME",+ "XDG_RUNTIME_DIR",+ "WAYLAND_DISPLAY",] as const) {if (!config.env[name] && shellEnvironment[name]) {config.env[name] = shellEnvironment[name];}}++ if (+ config.platform === "linux" &&+ Option.isNone(trimNonEmpty(config.env.DBUS_SESSION_BUS_ADDRESS))+ ) {+ for (const runtimeDir of linuxRuntimeDirCandidates(config.env, process.getuid?.())) {+ const dbusSessionBusPath = `${runtimeDir}/bus`;+ const busExists = yield* fileSystem+ .exists(dbusSessionBusPath)+ .pipe(Effect.orElseSucceed(() => false));+ if (busExists) {+ config.env.DBUS_SESSION_BUS_ADDRESS = `unix:path=${dbusSessionBusPath}`;+ break;+ }+ }+ }},);const installShellEnvironment = (config: ShellEnvironmentConfig,-): Effect.Effect<void, never, ChildProcessSpawner.ChildProcessSpawner> => {+): Effect.Effect<void, never, ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem> => {if (config.platform === "win32") {return installWindowsEnvironment(config);}@@ -411,6 +496,7 @@ const installShellEnvironment = (export const make = Effect.gen(function* () {const environment = yield* DesktopEnvironment.DesktopEnvironment;+ const fileSystem = yield* FileSystem.FileSystem;const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;const installIntoProcess: DesktopShellEnvironment["Service"]["installIntoProcess"] =installShellEnvironment({@@ -418,6 +504,7 @@ export const make = Effect.gen(function* () {platform: environment.platform,userShell: Option.none(),}).pipe(+ Effect.provideService(FileSystem.FileSystem, fileSystem),Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),Effect.withSpan("desktop.shellEnvironment.installIntoProcess"),);diff --git a/apps/desktop/src/telemetry/DesktopTelemetryPublisher.test.ts b/apps/desktop/src/telemetry/DesktopTelemetryPublisher.test.tsindex 36cdcb50b..112c0ab35 100644--- a/apps/desktop/src/telemetry/DesktopTelemetryPublisher.test.ts+++ b/apps/desktop/src/telemetry/DesktopTelemetryPublisher.test.ts@@ -43,6 +43,7 @@ function makeElectronAppLayer(setDesktopName: () => Effect.void,setDockIcon: () => Effect.void,appendCommandLineSwitch: () => Effect.void,+ removeCommandLineSwitch: () => Effect.void,onBeforeQuitForUpdate: () => Effect.void,on: () => Effect.void,} satisfies ElectronApp.ElectronApp["Service"]);diff --git a/apps/desktop/src/window/DesktopApplicationMenu.test.ts b/apps/desktop/src/window/DesktopApplicationMenu.test.tsindex f04a49f82..136cf8204 100644--- a/apps/desktop/src/window/DesktopApplicationMenu.test.ts+++ b/apps/desktop/src/window/DesktopApplicationMenu.test.ts@@ -46,6 +46,7 @@ const electronAppLayer = Layer.succeed(ElectronApp.ElectronApp, {setDockIcon: () => Effect.void,appendCommandLineSwitch: () => Effect.void,onBeforeQuitForUpdate: () => Effect.void,+ removeCommandLineSwitch: () => Effect.void,on: () => Effect.void,} satisfies ElectronApp.ElectronApp["Service"]);