kanna-code 0.35.2 → 0.36.1

package/src/server/app-settings.ts

@@ -4,11 +4,48 @@ import { mkdir, readFile, writeFile } from "node:fs/promises"
 import { homedir } from "node:os"
 import path from "node:path"
 import { getSettingsFilePath, LOG_PREFIX } from "../shared/branding"
-import type { AppSettingsSnapshot } from "../shared/types"
+import {
+  DEFAULT_CLAUDE_MODEL_OPTIONS,
+  DEFAULT_CODEX_MODEL_OPTIONS,
+  isClaudeReasoningEffort,
+  isCodexReasoningEffort,
+  normalizeClaudeContextWindow,
+  normalizeClaudeModelId,
+  normalizeCodexModelId,
+  supportsClaudeMaxReasoningEffort,
+  type AppSettingsPatch,
+  type AppSettingsSnapshot,
+  type AppThemePreference,
+  type ChatProviderPreferences,
+  type ChatSoundId,
+  type ChatSoundPreference,
+  type ClaudeModelOptions,
+  type CodexModelOptions,
+  type DefaultProviderPreference,
+  type EditorPreset,
+  type ProviderPreference,
+} from "../shared/types"
 
 interface AppSettingsFile {
   analyticsEnabled?: unknown
   analyticsUserId?: unknown
+  browserSettingsMigrated?: unknown
+  theme?: unknown
+  chatSoundPreference?: unknown
+  chatSoundId?: unknown
+  terminal?: {
+    scrollbackLines?: unknown
+    minColumnWidth?: unknown
+  }
+  editor?: {
+    preset?: unknown
+    commandTemplate?: unknown
+  }
+  defaultProvider?: unknown
+  providerDefaults?: {
+    claude?: Partial<ProviderPreference<Partial<ClaudeModelOptions>>> & { effort?: unknown }
+    codex?: Partial<ProviderPreference<Partial<CodexModelOptions>>> & { effort?: unknown }
+  }
 }
 
 interface AppSettingsState extends AppSettingsSnapshot {
@@ -16,14 +53,21 @@ interface AppSettingsState extends AppSettingsSnapshot {
 }
 
 interface NormalizedAppSettings {
-  payload: {
-    analyticsEnabled: boolean
-    analyticsUserId: string
-  }
+  payload: AppSettingsState
   warning: string | null
   shouldWrite: boolean
 }
 
+const DEFAULT_TERMINAL_SCROLLBACK = 1_000
+const MIN_TERMINAL_SCROLLBACK = 500
+const MAX_TERMINAL_SCROLLBACK = 5_000
+const DEFAULT_TERMINAL_MIN_COLUMN_WIDTH = 450
+const MIN_TERMINAL_MIN_COLUMN_WIDTH = 250
+const MAX_TERMINAL_MIN_COLUMN_WIDTH = 900
+const DEFAULT_EDITOR_PRESET: EditorPreset = "cursor"
+const DEFAULT_CHAT_SOUND_PREFERENCE: ChatSoundPreference = "always"
+const DEFAULT_CHAT_SOUND_ID: ChatSoundId = "funk"
+
 function formatDisplayPath(filePath: string) {
   const homePath = homedir()
   if (filePath === homePath) return "~"
@@ -37,6 +81,168 @@ function createAnalyticsUserId() {
   return `anon_${randomUUID()}`
 }
 
+function getDefaultEditorCommandTemplate(preset: EditorPreset) {
+  switch (preset) {
+    case "vscode":
+      return "code {path}"
+    case "xcode":
+      return "xed {path}"
+    case "windsurf":
+      return "windsurf {path}"
+    case "custom":
+    case "cursor":
+    default:
+      return "cursor {path}"
+  }
+}
+
+function createDefaultProviderDefaults(): ChatProviderPreferences {
+  return {
+    claude: {
+      model: "claude-opus-4-7",
+      modelOptions: { ...DEFAULT_CLAUDE_MODEL_OPTIONS },
+      planMode: false,
+    },
+    codex: {
+      model: "gpt-5.5",
+      modelOptions: { ...DEFAULT_CODEX_MODEL_OPTIONS },
+      planMode: false,
+    },
+  }
+}
+
+function clampNumber(value: unknown, fallback: number, min: number, max: number) {
+  const numberValue = typeof value === "number" ? value : Number(value)
+  if (!Number.isFinite(numberValue)) return fallback
+  return Math.min(max, Math.max(min, Math.round(numberValue)))
+}
+
+function normalizeTheme(value: unknown): AppThemePreference {
+  return value === "light" || value === "dark" || value === "system" ? value : "system"
+}
+
+function normalizeChatSoundPreference(value: unknown): ChatSoundPreference {
+  return value === "never" || value === "unfocused" || value === "always" ? value : DEFAULT_CHAT_SOUND_PREFERENCE
+}
+
+function normalizeChatSoundId(value: unknown): ChatSoundId {
+  switch (value) {
+    case "blow":
+    case "bottle":
+    case "frog":
+    case "funk":
+    case "glass":
+    case "ping":
+    case "pop":
+    case "purr":
+    case "tink":
+      return value
+    default:
+      return DEFAULT_CHAT_SOUND_ID
+  }
+}
+
+function normalizeDefaultProvider(value: unknown): DefaultProviderPreference {
+  return value === "claude" || value === "codex" || value === "last_used" ? value : "last_used"
+}
+
+function normalizeEditorPreset(value: unknown): EditorPreset {
+  return value === "vscode" || value === "xcode" || value === "windsurf" || value === "custom" || value === "cursor"
+    ? value
+    : DEFAULT_EDITOR_PRESET
+}
+
+function normalizeEditorCommandTemplate(value: unknown, preset: EditorPreset) {
+  const trimmed = typeof value === "string" ? value.trim() : ""
+  return trimmed || getDefaultEditorCommandTemplate(preset)
+}
+
+function normalizeClaudePreference(value?: {
+  model?: unknown
+  effort?: unknown
+  modelOptions?: Partial<Record<keyof ClaudeModelOptions, unknown>>
+  planMode?: unknown
+}): ProviderPreference<ClaudeModelOptions> {
+  const model = normalizeClaudeModelId(typeof value?.model === "string" ? value.model : undefined)
+  const reasoningEffort = value?.modelOptions?.reasoningEffort
+  const normalizedEffort = isClaudeReasoningEffort(reasoningEffort)
+    ? reasoningEffort
+    : isClaudeReasoningEffort(value?.effort)
+      ? value.effort
+      : DEFAULT_CLAUDE_MODEL_OPTIONS.reasoningEffort
+
+  return {
+    model,
+    modelOptions: {
+      reasoningEffort: !supportsClaudeMaxReasoningEffort(model) && normalizedEffort === "max" ? "high" : normalizedEffort,
+      contextWindow: normalizeClaudeContextWindow(model, value?.modelOptions?.contextWindow),
+    },
+    planMode: value?.planMode === true,
+  }
+}
+
+function normalizeCodexPreference(value?: {
+  model?: unknown
+  effort?: unknown
+  modelOptions?: Partial<Record<keyof CodexModelOptions, unknown>>
+  planMode?: unknown
+}): ProviderPreference<CodexModelOptions> {
+  const reasoningEffort = value?.modelOptions?.reasoningEffort
+  return {
+    model: normalizeCodexModelId(typeof value?.model === "string" ? value.model : undefined),
+    modelOptions: {
+      reasoningEffort: isCodexReasoningEffort(reasoningEffort)
+        ? reasoningEffort
+        : isCodexReasoningEffort(value?.effort)
+          ? value.effort
+          : DEFAULT_CODEX_MODEL_OPTIONS.reasoningEffort,
+      fastMode: typeof value?.modelOptions?.fastMode === "boolean"
+        ? value.modelOptions.fastMode
+        : DEFAULT_CODEX_MODEL_OPTIONS.fastMode,
+    },
+    planMode: value?.planMode === true,
+  }
+}
+
+function normalizeProviderDefaults(value: AppSettingsFile["providerDefaults"] | undefined): ChatProviderPreferences {
+  const defaults = createDefaultProviderDefaults()
+  return {
+    claude: normalizeClaudePreference(value?.claude ?? defaults.claude),
+    codex: normalizeCodexPreference(value?.codex ?? defaults.codex),
+  }
+}
+
+function toFilePayload(state: AppSettingsState) {
+  return {
+    analyticsEnabled: state.analyticsEnabled,
+    analyticsUserId: state.analyticsUserId,
+    browserSettingsMigrated: state.browserSettingsMigrated,
+    theme: state.theme,
+    chatSoundPreference: state.chatSoundPreference,
+    chatSoundId: state.chatSoundId,
+    terminal: state.terminal,
+    editor: state.editor,
+    defaultProvider: state.defaultProvider,
+    providerDefaults: state.providerDefaults,
+  }
+}
+
+function toSnapshot(state: AppSettingsState): AppSettingsSnapshot {
+  return {
+    analyticsEnabled: state.analyticsEnabled,
+    browserSettingsMigrated: state.browserSettingsMigrated,
+    theme: state.theme,
+    chatSoundPreference: state.chatSoundPreference,
+    chatSoundId: state.chatSoundId,
+    terminal: state.terminal,
+    editor: state.editor,
+    defaultProvider: state.defaultProvider,
+    providerDefaults: state.providerDefaults,
+    warning: state.warning,
+    filePathDisplay: state.filePathDisplay,
+  }
+}
+
 function normalizeAppSettings(
   value: unknown,
   filePath = getSettingsFilePath(homedir())
@@ -50,80 +256,122 @@ function normalizeAppSettings(
     warnings.push("Settings file must contain a JSON object")
   }
 
-  const analyticsEnabled = typeof source?.analyticsEnabled === "boolean"
-    ? source.analyticsEnabled
-    : true
+  const analyticsEnabled = typeof source?.analyticsEnabled === "boolean" ? source.analyticsEnabled : true
   if (source?.analyticsEnabled !== undefined && typeof source.analyticsEnabled !== "boolean") {
     warnings.push("analyticsEnabled must be a boolean")
   }
 
-  const rawAnalyticsUserId = typeof source?.analyticsUserId === "string"
-    ? source.analyticsUserId.trim()
-    : ""
+  const rawAnalyticsUserId = typeof source?.analyticsUserId === "string" ? source.analyticsUserId.trim() : ""
   if (source?.analyticsUserId !== undefined && typeof source.analyticsUserId !== "string") {
     warnings.push("analyticsUserId must be a string")
   }
-
   const analyticsUserId = rawAnalyticsUserId || createAnalyticsUserId()
   if (!rawAnalyticsUserId && source?.analyticsUserId !== undefined) {
     warnings.push("analyticsUserId must be a non-empty string")
   }
 
-  const shouldWrite = !source
-    || source.analyticsEnabled !== analyticsEnabled
-    || rawAnalyticsUserId !== analyticsUserId
+  const editorPreset = normalizeEditorPreset(source?.editor?.preset)
+  const state: AppSettingsState = {
+    analyticsEnabled,
+    analyticsUserId,
+    browserSettingsMigrated: source?.browserSettingsMigrated === true,
+    theme: normalizeTheme(source?.theme),
+    chatSoundPreference: normalizeChatSoundPreference(source?.chatSoundPreference),
+    chatSoundId: normalizeChatSoundId(source?.chatSoundId),
+    terminal: {
+      scrollbackLines: clampNumber(source?.terminal?.scrollbackLines, DEFAULT_TERMINAL_SCROLLBACK, MIN_TERMINAL_SCROLLBACK, MAX_TERMINAL_SCROLLBACK),
+      minColumnWidth: clampNumber(source?.terminal?.minColumnWidth, DEFAULT_TERMINAL_MIN_COLUMN_WIDTH, MIN_TERMINAL_MIN_COLUMN_WIDTH, MAX_TERMINAL_MIN_COLUMN_WIDTH),
+    },
+    editor: {
+      preset: editorPreset,
+      commandTemplate: normalizeEditorCommandTemplate(source?.editor?.commandTemplate, editorPreset),
+    },
+    defaultProvider: normalizeDefaultProvider(source?.defaultProvider),
+    providerDefaults: normalizeProviderDefaults(source?.providerDefaults),
+    warning: null,
+    filePathDisplay: formatDisplayPath(filePath),
+  }
+
+  const shouldWrite = JSON.stringify(source ? toComparablePayload(source) : null) !== JSON.stringify(toFilePayload(state))
+  state.warning = warnings.length > 0
+    ? `Some settings were reset to defaults: ${warnings.join("; ")}`
+    : null
 
   return {
-    payload: {
-      analyticsEnabled,
-      analyticsUserId,
-    },
-    warning: warnings.length > 0
-      ? `Some settings were reset to defaults: ${warnings.join("; ")}`
-      : null,
+    payload: state,
+    warning: state.warning,
     shouldWrite,
   }
 }
 
-function toSnapshot(state: AppSettingsState): AppSettingsSnapshot {
+function toComparablePayload(source: AppSettingsFile) {
   return {
-    analyticsEnabled: state.analyticsEnabled,
-    warning: state.warning,
-    filePathDisplay: state.filePathDisplay,
+    analyticsEnabled: source.analyticsEnabled,
+    analyticsUserId: typeof source.analyticsUserId === "string" ? source.analyticsUserId.trim() : source.analyticsUserId,
+    browserSettingsMigrated: source.browserSettingsMigrated,
+    theme: source.theme,
+    chatSoundPreference: source.chatSoundPreference,
+    chatSoundId: source.chatSoundId,
+    terminal: source.terminal,
+    editor: source.editor,
+    defaultProvider: source.defaultProvider,
+    providerDefaults: source.providerDefaults,
   }
 }
 
+function applyPatch(state: AppSettingsState, patch: AppSettingsPatch): AppSettingsState {
+  return normalizeAppSettings({
+    ...toFilePayload(state),
+    ...patch,
+    terminal: {
+      ...state.terminal,
+      ...patch.terminal,
+    },
+    editor: {
+      ...state.editor,
+      ...patch.editor,
+    },
+    providerDefaults: {
+      claude: {
+        ...state.providerDefaults.claude,
+        ...patch.providerDefaults?.claude,
+        modelOptions: {
+          ...state.providerDefaults.claude.modelOptions,
+          ...patch.providerDefaults?.claude?.modelOptions,
+        },
+      },
+      codex: {
+        ...state.providerDefaults.codex,
+        ...patch.providerDefaults?.codex,
+        modelOptions: {
+          ...state.providerDefaults.codex.modelOptions,
+          ...patch.providerDefaults?.codex?.modelOptions,
+        },
+      },
+    },
+  }, state.filePathDisplay).payload
+}
+
 export async function readAppSettingsSnapshot(filePath = getSettingsFilePath(homedir())) {
   try {
     const text = await readFile(filePath, "utf8")
     if (!text.trim()) {
       const normalized = normalizeAppSettings(undefined, filePath)
       return {
-        analyticsEnabled: normalized.payload.analyticsEnabled,
+        ...toSnapshot(normalized.payload),
         warning: "Settings file was empty. Using defaults.",
-        filePathDisplay: formatDisplayPath(filePath),
       } satisfies AppSettingsSnapshot
     }
 
-    const normalized = normalizeAppSettings(JSON.parse(text), filePath)
-    return {
-      analyticsEnabled: normalized.payload.analyticsEnabled,
-      warning: normalized.warning,
-      filePathDisplay: formatDisplayPath(filePath),
-    } satisfies AppSettingsSnapshot
+    return toSnapshot(normalizeAppSettings(JSON.parse(text), filePath).payload)
   } catch (error) {
     if ((error as NodeJS.ErrnoException)?.code === "ENOENT") {
-      return {
-        analyticsEnabled: true,
-        warning: null,
-        filePathDisplay: formatDisplayPath(filePath),
-      } satisfies AppSettingsSnapshot
+      return toSnapshot(normalizeAppSettings(undefined, filePath).payload)
     }
     if (error instanceof SyntaxError) {
       return {
-        analyticsEnabled: true,
+        ...toSnapshot(normalizeAppSettings(undefined, filePath).payload),
         warning: "Settings file is invalid JSON. Using defaults.",
-        filePathDisplay: formatDisplayPath(filePath),
       } satisfies AppSettingsSnapshot
     }
     throw error
@@ -138,13 +386,7 @@ export class AppSettingsManager {
 
   constructor(filePath = getSettingsFilePath(homedir())) {
     this.filePath = filePath
-    const displayPath = formatDisplayPath(this.filePath)
-    this.state = {
-      analyticsEnabled: true,
-      analyticsUserId: createAnalyticsUserId(),
-      warning: null,
-      filePathDisplay: displayPath,
-    }
+    this.state = normalizeAppSettings(undefined, filePath).payload
   }
 
   async initialize() {
@@ -180,58 +422,47 @@ export class AppSettingsManager {
   }
 
   async write(value: { analyticsEnabled: boolean }) {
-    const payload = {
-      analyticsEnabled: value.analyticsEnabled,
-      analyticsUserId: this.state.analyticsUserId || createAnalyticsUserId(),
-    }
-    await mkdir(path.dirname(this.filePath), { recursive: true })
-    await writeFile(this.filePath, `${JSON.stringify(payload, null, 2)}\n`, "utf8")
-    const nextState: AppSettingsState = {
-      analyticsEnabled: payload.analyticsEnabled,
-      analyticsUserId: payload.analyticsUserId,
+    return this.writePatch({ analyticsEnabled: value.analyticsEnabled })
+  }
+
+  async writePatch(patch: AppSettingsPatch) {
+    const nextState = {
+      ...applyPatch(this.state, patch),
       warning: null,
       filePathDisplay: formatDisplayPath(this.filePath),
     }
+    await mkdir(path.dirname(this.filePath), { recursive: true })
+    await writeFile(this.filePath, `${JSON.stringify(toFilePayload(nextState), null, 2)}\n`, "utf8")
     this.setState(nextState)
     return toSnapshot(nextState)
   }
 
   private async readState(options?: { persistNormalized?: boolean }) {
     const file = Bun.file(this.filePath)
-    const displayPath = formatDisplayPath(this.filePath)
 
     try {
       const text = await file.text()
       const hasText = text.trim().length > 0
       const normalized = normalizeAppSettings(hasText ? JSON.parse(text) : undefined, this.filePath)
       if (options?.persistNormalized && (!hasText || normalized.shouldWrite)) {
-        await writeFile(this.filePath, `${JSON.stringify(normalized.payload, null, 2)}\n`, "utf8")
+        await writeFile(this.filePath, `${JSON.stringify(toFilePayload(normalized.payload), null, 2)}\n`, "utf8")
       }
       return {
-        analyticsEnabled: normalized.payload.analyticsEnabled,
-        analyticsUserId: normalized.payload.analyticsUserId,
-        warning: !hasText
-          ? "Settings file was empty. Using defaults."
-          : normalized.warning,
-        filePathDisplay: displayPath,
+        ...normalized.payload,
+        warning: !hasText ? "Settings file was empty. Using defaults." : normalized.warning,
       } satisfies AppSettingsState
     } catch (error) {
       if ((error as NodeJS.ErrnoException)?.code !== "ENOENT" && !(error instanceof SyntaxError)) {
         throw error
       }
 
-      const warning = error instanceof SyntaxError
-        ? "Settings file is invalid JSON. Using defaults."
-        : null
       const normalized = normalizeAppSettings(undefined, this.filePath)
       if (options?.persistNormalized) {
-        await writeFile(this.filePath, `${JSON.stringify(normalized.payload, null, 2)}\n`, "utf8")
+        await writeFile(this.filePath, `${JSON.stringify(toFilePayload(normalized.payload), null, 2)}\n`, "utf8")
       }
       return {
-        analyticsEnabled: normalized.payload.analyticsEnabled,
-        analyticsUserId: normalized.payload.analyticsUserId,
-        warning,
-        filePathDisplay: displayPath,
+        ...normalized.payload,
+        warning: error instanceof SyntaxError ? "Settings file is invalid JSON. Using defaults." : null,
       } satisfies AppSettingsState
     }
   }

package/src/server/external-open.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test"
-import { buildEditorCommand, tokenizeCommandTemplate } from "./external-open"
+import { buildDefaultOpenCommand, buildEditorCommand, buildPreviewCommand, tokenizeCommandTemplate } from "./external-open"
 
 describe("tokenizeCommandTemplate", () => {
   test("keeps quoted arguments together", () => {
@@ -74,3 +74,39 @@ describe("buildEditorCommand", () => {
     })
   })
 })
+
+describe("buildPreviewCommand", () => {
+  test("builds a native macOS Preview open command", () => {
+    expect(
+      buildPreviewCommand({
+        localPath: "/Users/jake/Projects/kanna/mock.png",
+        isDirectory: false,
+        platform: "darwin",
+      })
+    ).toEqual({
+      command: "open",
+      args: ["-a", "Preview", "/Users/jake/Projects/kanna/mock.png"],
+    })
+  })
+
+  test("rejects non-macOS platforms", () => {
+    expect(() => buildPreviewCommand({
+      localPath: "/Users/jake/Projects/kanna/mock.png",
+      isDirectory: false,
+      platform: "linux",
+    })).toThrow("Preview is only available on macOS")
+  })
+})
+
+describe("buildDefaultOpenCommand", () => {
+  test("builds default open commands for supported platforms", () => {
+    expect(buildDefaultOpenCommand({ localPath: "/Users/jake/Projects/kanna/mock.png", platform: "darwin" })).toEqual({
+      command: "open",
+      args: ["/Users/jake/Projects/kanna/mock.png"],
+    })
+    expect(buildDefaultOpenCommand({ localPath: "/tmp/mock.png", platform: "linux" })).toEqual({
+      command: "xdg-open",
+      args: ["/tmp/mock.png"],
+    })
+  })
+})

package/src/server/external-open.ts

@@ -20,7 +20,7 @@ const DEFAULT_EDITOR_SETTINGS: EditorOpenSettings = {
 export async function openExternal(command: OpenExternalCommand) {
   const resolvedPath = resolveLocalPath(command.localPath)
   const platform = process.platform
-  const info = command.action === "open_editor" || command.action === "open_finder"
+  const info = command.action === "open_editor" || command.action === "open_finder" || command.action === "open_preview" || command.action === "open_default"
     ? await stat(resolvedPath).catch(() => null)
     : null
 
@@ -41,6 +41,29 @@ export async function openExternal(command: OpenExternalCommand) {
   }
 
   if (platform === "darwin") {
+    if (command.action === "open_default") {
+      if (!info) {
+        throw new Error(`Path not found: ${resolvedPath}`)
+      }
+      const defaultCommand = buildDefaultOpenCommand({ localPath: resolvedPath, platform })
+      await spawnDetached(defaultCommand.command, defaultCommand.args)
+      return
+    }
+    if (command.action === "open_preview") {
+      if (!info) {
+        throw new Error(`Path not found: ${resolvedPath}`)
+      }
+      if (!canOpenMacApp("Preview")) {
+        throw new Error("Preview is not installed")
+      }
+      const previewCommand = buildPreviewCommand({
+        localPath: resolvedPath,
+        isDirectory: info.isDirectory(),
+        platform,
+      })
+      await spawnDetached(previewCommand.command, previewCommand.args)
+      return
+    }
     if (command.action === "open_finder") {
       if (info?.isDirectory()) {
         await spawnDetached("open", [resolvedPath])
@@ -59,6 +82,14 @@ export async function openExternal(command: OpenExternalCommand) {
   }
 
   if (platform === "win32") {
+    if (command.action === "open_default") {
+      if (!info) {
+        throw new Error(`Path not found: ${resolvedPath}`)
+      }
+      const defaultCommand = buildDefaultOpenCommand({ localPath: resolvedPath, platform })
+      await spawnDetached(defaultCommand.command, defaultCommand.args)
+      return
+    }
     if (command.action === "open_finder") {
       if (info?.isDirectory()) {
         await spawnDetached("explorer", [resolvedPath])
@@ -77,6 +108,19 @@ export async function openExternal(command: OpenExternalCommand) {
     }
   }
 
+  if (command.action === "open_preview") {
+    throw new Error("Preview is only available on macOS")
+  }
+
+  if (command.action === "open_default") {
+    if (!info) {
+      throw new Error(`Path not found: ${resolvedPath}`)
+    }
+    const defaultCommand = buildDefaultOpenCommand({ localPath: resolvedPath, platform })
+    await spawnDetached(defaultCommand.command, defaultCommand.args)
+    return
+  }
+
   if (command.action === "open_finder") {
     await spawnDetached("xdg-open", [info?.isDirectory() ? resolvedPath : path.dirname(resolvedPath)])
     return
@@ -117,6 +161,33 @@ export function buildEditorCommand(args: {
   return buildPresetEditorCommand(args, editor.preset)
 }
 
+export function buildPreviewCommand(args: {
+  localPath: string
+  isDirectory: boolean
+  platform: NodeJS.Platform
+}): CommandSpec {
+  if (args.platform !== "darwin") {
+    throw new Error("Preview is only available on macOS")
+  }
+  if (args.isDirectory) {
+    throw new Error("Preview cannot open directories")
+  }
+  return { command: "open", args: ["-a", "Preview", args.localPath] }
+}
+
+export function buildDefaultOpenCommand(args: {
+  localPath: string
+  platform: NodeJS.Platform
+}): CommandSpec {
+  if (args.platform === "darwin") {
+    return { command: "open", args: [args.localPath] }
+  }
+  if (args.platform === "win32") {
+    return { command: "cmd", args: ["/c", "start", "", args.localPath] }
+  }
+  return { command: "xdg-open", args: [args.localPath] }
+}
+
 function buildPresetEditorCommand(
   args: {
     localPath: string