feat(desktop): add desktop config file

Author: anduimagui

packages/app/package.json

@@ -5,6 +5,7 @@
   "type": "module",
   "exports": {
     ".": "./src/index.ts",
+    "./desktop-config": "./src/desktop-config.ts",
     "./desktop-menu": "./src/desktop-menu.ts",
     "./updater": "./src/updater.ts",
     "./wsl/types": "./src/wsl/types.ts",

packages/app/src/context/permission.tsx

@@ -5,6 +5,7 @@ import type { PermissionRequest } from "@opencode-ai/sdk/v2/client"
 import { Persist, persisted } from "@/utils/persist"
 import { useServerSDK } from "@/context/server-sdk"
 import { useServerSync } from "./server-sync"
+import { usePlatform } from "./platform"
 import { useParams } from "@solidjs/router"
 import { decode64 } from "@/utils/base64"
 import {
@@ -49,8 +50,12 @@ export const { use: usePermission, provider: PermissionProvider } = createSimple
   gate: false,
   init: () => {
     const params = useParams()
+    const platform = usePlatform()
     const serverSDK = useServerSDK()
     const serverSync = useServerSync()
+    const autoApprove = createMemo(
+      () => platform.platform === "desktop" && platform.desktopConfig?.()?.permissions?.autoApprove === true,
+    )
 
     const permissionsEnabled = createMemo(() => {
       const directory = decode64(params.dir)
@@ -142,15 +147,18 @@ export const { use: usePermission, provider: PermissionProvider } = createSimple
     }
 
     function isAutoAccepting(sessionID: string, directory?: string) {
+      if (autoApprove()) return true
       const session = directory ? serverSync().child(directory, { bootstrap: false })[0].session : []
       return autoRespondsPermission(store.autoAccept, session, { sessionID }, directory)
     }
 
     function isAutoAcceptingDirectory(directory: string) {
+      if (autoApprove()) return true
       return isDirectoryAutoAccepting(store.autoAccept, directory)
     }
 
     function shouldAutoRespond(permission: PermissionRequest, directory?: string) {
+      if (autoApprove()) return true
       const session = directory ? serverSync().child(directory, { bootstrap: false })[0].session : []
       return autoRespondsPermission(store.autoAccept, session, permission, directory)
     }

packages/app/src/context/platform.tsx

@@ -5,6 +5,7 @@ import type { DesktopMenuAction } from "../desktop-menu"
 import { ServerConnection } from "./server"
 import type { WslServersPlatform } from "../wsl/types"
 import type { UpdaterPlatform } from "../updater"
+import type { DesktopConfig } from "../desktop-config"
 
 type PickerPaths = string | string[] | null
 type OpenDirectoryPickerOptions = { title?: string; multiple?: boolean }
@@ -111,6 +112,9 @@ type PlatformBase = {
 
   /** Record a fatal renderer error in platform logs (desktop only) */
   recordFatalRendererError?(error: FatalRendererErrorLog): Promise<void>
+
+  /** Desktop-only machine config loaded from ~/.config/opencode/desktop.json */
+  desktopConfig?: Accessor<DesktopConfig | undefined>
 }
 
 export type Platform = PlatformBase &

packages/app/src/context/settings.tsx

@@ -2,6 +2,7 @@ import { createStore, reconcile } from "solid-js/store"
 import { createEffect, createMemo } from "solid-js"
 import { createSimpleContext } from "@opencode-ai/ui/context"
 import { persisted } from "@/utils/persist"
+import { usePlatform } from "./platform"
 
 export interface NotificationSettings {
   agent: boolean
@@ -148,10 +149,16 @@ function withFallback<T>(read: () => T | undefined, fallback: T) {
   return createMemo(() => read() ?? fallback)
 }
 
+function desktopFallback<T>(read: () => T | undefined, config: () => T | undefined, fallback: T) {
+  return createMemo(() => config() ?? read() ?? fallback)
+}
+
 export const { use: useSettings, provider: SettingsProvider } = createSimpleContext({
   name: "Settings",
   gate: false,
   init: () => {
+    const platform = usePlatform()
+    const desktopConfig = () => (platform.platform === "desktop" ? platform.desktopConfig?.() : undefined)
     const [store, setStore, _, ready] = persisted("settings.v3", createStore<Settings>(defaultSettings))
     const showFileTree = withFallback(() => store.general?.showFileTree, defaultSettings.general.showFileTree)
     const showSearch = withFallback(() => store.general?.showSearch, defaultSettings.general.showSearch)
@@ -295,7 +302,11 @@ export const { use: useSettings, provider: SettingsProvider } = createSimpleCont
         },
       },
       permissions: {
-        autoApprove: withFallback(() => store.permissions?.autoApprove, defaultSettings.permissions.autoApprove),
+        autoApprove: desktopFallback(
+          () => store.permissions?.autoApprove,
+          () => desktopConfig()?.permissions?.autoApprove,
+          defaultSettings.permissions.autoApprove,
+        ),
         setAutoApprove(value: boolean) {
           setStore("permissions", "autoApprove", value)
         },
@@ -315,30 +326,51 @@ export const { use: useSettings, provider: SettingsProvider } = createSimpleCont
         },
       },
       sounds: {
-        agentEnabled: withFallback(() => store.sounds?.agentEnabled, defaultSettings.sounds.agentEnabled),
+        agentEnabled: desktopFallback(
+          () => store.sounds?.agentEnabled,
+          () => desktopConfig()?.sounds?.agentEnabled,
+          defaultSettings.sounds.agentEnabled,
+        ),
         setAgentEnabled(value: boolean) {
           setStore("sounds", "agentEnabled", value)
         },
-        agent: withFallback(() => store.sounds?.agent, defaultSettings.sounds.agent),
+        agent: desktopFallback(
+          () => store.sounds?.agent,
+          () => desktopConfig()?.sounds?.agent,
+          defaultSettings.sounds.agent,
+        ),
         setAgent(value: string) {
           setStore("sounds", "agent", value)
         },
-        permissionsEnabled: withFallback(
+        permissionsEnabled: desktopFallback(
           () => store.sounds?.permissionsEnabled,
+          () => desktopConfig()?.sounds?.permissionsEnabled,
           defaultSettings.sounds.permissionsEnabled,
         ),
         setPermissionsEnabled(value: boolean) {
           setStore("sounds", "permissionsEnabled", value)
         },
-        permissions: withFallback(() => store.sounds?.permissions, defaultSettings.sounds.permissions),
+        permissions: desktopFallback(
+          () => store.sounds?.permissions,
+          () => desktopConfig()?.sounds?.permissions,
+          defaultSettings.sounds.permissions,
+        ),
         setPermissions(value: string) {
           setStore("sounds", "permissions", value)
         },
-        errorsEnabled: withFallback(() => store.sounds?.errorsEnabled, defaultSettings.sounds.errorsEnabled),
+        errorsEnabled: desktopFallback(
+          () => store.sounds?.errorsEnabled,
+          () => desktopConfig()?.sounds?.errorsEnabled,
+          defaultSettings.sounds.errorsEnabled,
+        ),
         setErrorsEnabled(value: boolean) {
           setStore("sounds", "errorsEnabled", value)
         },
-        errors: withFallback(() => store.sounds?.errors, defaultSettings.sounds.errors),
+        errors: desktopFallback(
+          () => store.sounds?.errors,
+          () => desktopConfig()?.sounds?.errors,
+          defaultSettings.sounds.errors,
+        ),
         setErrors(value: string) {
           setStore("sounds", "errors", value)
         },

packages/app/src/desktop-config.test.ts

@@ -0,0 +1,75 @@
+import { expect, test } from "bun:test"
+import { decodeDesktopConfig, decodeDesktopConfigJson } from "./desktop-config"
+
+test("decodes supported desktop config values", () => {
+  expect(
+    decodeDesktopConfig({
+      permissions: {
+        autoApprove: true,
+      },
+      sounds: {
+        agentEnabled: false,
+        agent: "glass",
+        permissionsEnabled: true,
+        permissions: "ping",
+        errorsEnabled: false,
+        errors: "alert",
+      },
+    }),
+  ).toEqual({
+    permissions: {
+      autoApprove: true,
+    },
+    sounds: {
+      agentEnabled: false,
+      agent: "glass",
+      permissionsEnabled: true,
+      permissions: "ping",
+      errorsEnabled: false,
+      errors: "alert",
+    },
+  })
+})
+
+test("ignores unknown keys and wrong primitive types", () => {
+  expect(
+    decodeDesktopConfig({
+      permissions: {
+        autoApprove: "yes",
+        extra: true,
+      },
+      sounds: {
+        agentEnabled: 1,
+        agent: "glass",
+        permissionsEnabled: true,
+        permissions: false,
+        errorsEnabled: false,
+        errors: "alert",
+        extra: "ignored",
+      },
+      extra: {
+        value: true,
+      },
+    }),
+  ).toEqual({
+    permissions: {},
+    sounds: {
+      agent: "glass",
+      permissionsEnabled: true,
+      errorsEnabled: false,
+      errors: "alert",
+    },
+  })
+})
+
+test("decodes desktop config from JSON strings", () => {
+  expect(decodeDesktopConfigJson(`{"permissions":{"autoApprove":true}}`)).toEqual({
+    permissions: {
+      autoApprove: true,
+    },
+  })
+})
+
+test("rejects malformed desktop config JSON", () => {
+  expect(decodeDesktopConfigJson("{")).toBeUndefined()
+})

packages/app/src/desktop-config.ts

@@ -0,0 +1,64 @@
+import { Option, Schema } from "effect"
+
+const PermissionsSchema = Schema.Struct({
+  autoApprove: Schema.optional(Schema.Boolean),
+})
+
+const SoundsSchema = Schema.Struct({
+  agentEnabled: Schema.optional(Schema.Boolean),
+  agent: Schema.optional(Schema.String),
+  permissionsEnabled: Schema.optional(Schema.Boolean),
+  permissions: Schema.optional(Schema.String),
+  errorsEnabled: Schema.optional(Schema.Boolean),
+  errors: Schema.optional(Schema.String),
+})
+
+export const DesktopConfigSchema = Schema.Struct({
+  permissions: Schema.optional(PermissionsSchema),
+  sounds: Schema.optional(SoundsSchema),
+})
+
+export type DesktopConfig = typeof DesktopConfigSchema.Type
+
+const decodeJson = Schema.decodeUnknownOption(Schema.UnknownFromJsonString)
+const decodeRecord = Schema.decodeUnknownOption(Schema.Record(Schema.String, Schema.Unknown))
+const decodeBoolean = Schema.decodeUnknownOption(Schema.Boolean)
+const decodeString = Schema.decodeUnknownOption(Schema.String)
+
+export function decodeDesktopConfigJson(value: string) {
+  const parsed = Option.getOrUndefined(decodeJson(value))
+  if (parsed === undefined) return
+  return decodeDesktopConfig(parsed)
+}
+
+export function decodeDesktopConfig(value: unknown): DesktopConfig | undefined {
+  const data = Option.getOrUndefined(decodeRecord(value))
+  if (!data) return
+
+  const permissions = Option.getOrUndefined(decodeRecord(data.permissions))
+  const sounds = Option.getOrUndefined(decodeRecord(data.sounds))
+
+  return stripUndefined({
+    permissions: permissions
+      ? stripUndefined({
+          autoApprove: Option.getOrUndefined(decodeBoolean(permissions.autoApprove)),
+        })
+      : undefined,
+    sounds: sounds
+      ? stripUndefined({
+          agentEnabled: Option.getOrUndefined(decodeBoolean(sounds.agentEnabled)),
+          agent: Option.getOrUndefined(decodeString(sounds.agent)),
+          permissionsEnabled: Option.getOrUndefined(decodeBoolean(sounds.permissionsEnabled)),
+          permissions: Option.getOrUndefined(decodeString(sounds.permissions)),
+          errorsEnabled: Option.getOrUndefined(decodeBoolean(sounds.errorsEnabled)),
+          errors: Option.getOrUndefined(decodeString(sounds.errors)),
+        })
+      : undefined,
+  })
+}
+
+function stripUndefined<T extends Record<string, unknown>>(value: T) {
+  return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined)) as {
+    [K in keyof T as undefined extends T[K] ? K : K]: Exclude<T[K], undefined>
+  }
+}

packages/app/src/index.ts

@@ -3,6 +3,7 @@ export { ACCEPTED_FILE_EXTENSIONS, ACCEPTED_FILE_TYPES, filePickerFilters } from
 export { useCommand } from "./context/command"
 export { loadLocaleDict, normalizeLocale, type Locale } from "./context/language"
 export { useWslServers } from "./wsl/context"
+export { type DesktopConfig } from "./desktop-config"
 export { type DisplayBackend, type FatalRendererErrorLog, type Platform, PlatformProvider } from "./context/platform"
 export { type UpdaterPlatform, type UpdaterState } from "./updater"
 export {

packages/desktop/src/main/desktop-config.test.ts

@@ -0,0 +1,60 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { afterEach, expect, test } from "bun:test"
+import { readDesktopConfig } from "./desktop-config"
+
+const previousXdgConfigHome = process.env.XDG_CONFIG_HOME
+
+afterEach(() => {
+  process.env.XDG_CONFIG_HOME = previousXdgConfigHome
+})
+
+test("reads supported desktop config values", async () => {
+  process.env.XDG_CONFIG_HOME = await mkdtemp(join(tmpdir(), "opencode-desktop-config-"))
+  await mkdir(join(process.env.XDG_CONFIG_HOME, "opencode"))
+  await writeFile(
+    join(process.env.XDG_CONFIG_HOME, "opencode", "desktop.json"),
+    JSON.stringify({
+      permissions: {
+        autoApprove: true,
+        unsupported: true,
+      },
+      sounds: {
+        agentEnabled: false,
+        agent: "glass",
+        permissionsEnabled: true,
+        permissions: "ping",
+        errorsEnabled: false,
+        errors: "alert",
+      },
+    }),
+  )
+
+  expect(await readDesktopConfig()).toEqual({
+    permissions: {
+      autoApprove: true,
+    },
+    sounds: {
+      agentEnabled: false,
+      agent: "glass",
+      permissionsEnabled: true,
+      permissions: "ping",
+      errorsEnabled: false,
+      errors: "alert",
+    },
+  })
+
+  await rm(process.env.XDG_CONFIG_HOME, { recursive: true, force: true })
+})
+
+test("ignores missing or malformed desktop config", async () => {
+  process.env.XDG_CONFIG_HOME = await mkdtemp(join(tmpdir(), "opencode-desktop-config-"))
+  expect(await readDesktopConfig()).toBeUndefined()
+
+  await mkdir(join(process.env.XDG_CONFIG_HOME, "opencode"))
+  await writeFile(join(process.env.XDG_CONFIG_HOME, "opencode", "desktop.json"), "{")
+  expect(await readDesktopConfig()).toBeUndefined()
+
+  await rm(process.env.XDG_CONFIG_HOME, { recursive: true, force: true })
+})