@aiworker/web 1.22.0 → 1.23.0

package/server/lib/opencode/settings-files.js

@@ -0,0 +1,214 @@
+// The two settings files and how a merged document is split between them.
+//
+// `settings.json` holds instance facts (and, untouched, whatever legacy keys
+// older builds left there). `preferences.json` holds the user's profile: the
+// keys the settings registry marks `profile`, each with the time the store
+// last accepted a new value for it. Device keys never reach either file.
+//
+// The VS Code extension host writes the same two files with the same shape
+// (`packages/vscode/src/settings-files.ts`); keep the format changes in sync.
+import { createRequire } from 'node:module';
+
+const registry = createRequire(import.meta.url)('./settings-registry.json');
+
+const PREFERENCES_FILE_NAME = 'preferences.json';
+const PREFERENCES_DOCUMENT_VERSION = 1;
+
+/** The registry scope for a key, or `null` when the registry does not know it. */
+const getSettingsScope = (key) => registry.fields[key]?.scope ?? null;
+
+export const isProfileSettingsKey = (key) => getSettingsScope(key) === 'profile';
+export const isDeviceSettingsKey = (key) => getSettingsScope(key) === 'device';
+
+/** Profile keys the owner chose to store per surface kind (a change on a phone stays on phones). */
+const isPerSurfaceSettingsKey = (key) => registry.fields[key]?.perSurface === true;
+
+const SETTINGS_SURFACES = Object.freeze(['web', 'desktop', 'vscode', 'mobile']);
+
+export const normalizeSettingsSurface = (value) => (
+  typeof value === 'string' && SETTINGS_SURFACES.includes(value.trim()) ? value.trim() : null
+);
+
+/**
+ * Which surface kind a settings request comes from; `null` means "base".
+ * Clients send `?surface=<kind>` (a query parameter keeps the request
+ * CORS-simple for cross-origin shells and older instances); the
+ * `x-openchamber-surface` header is still honoured for clients that sent it.
+ */
+export const settingsSurfaceOf = (req) => (
+  normalizeSettingsSurface(req.query?.surface) ?? normalizeSettingsSurface(req.get?.('x-openchamber-surface'))
+);
+
+export const preferencesFilePathFor = (settingsFilePath, path) => path.join(path.dirname(settingsFilePath), PREFERENCES_FILE_NAME);
+
+const isPlainObject = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+
+const sameValue = (left, right) => {
+  if (left === right) return true;
+  if (left === undefined || right === undefined) return false;
+  return JSON.stringify(left) === JSON.stringify(right);
+};
+
+const parseStamp = (value) => (Number.isFinite(value) ? value : 0);
+
+/**
+ * Parse the text of a preferences file. A missing file is the caller's case
+ * (ENOENT); anything that is not a version-1 document with a `fields` object
+ * is a failure, never an empty profile.
+ *
+ * An entry is `{ value, updatedAt }` for the base value, optionally with
+ * `surfaces: { [surface]: { value, updatedAt } }` for per-surface keys; a
+ * per-surface key that was only ever set from one surface kind has no base.
+ */
+export const parsePreferencesDocument = (raw) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    return { ok: false, reason: `invalid JSON: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  if (!isPlainObject(parsed) || parsed.version !== PREFERENCES_DOCUMENT_VERSION || !isPlainObject(parsed.fields)) {
+    return { ok: false, reason: 'not a version-1 preferences document' };
+  }
+  const fields = {};
+  for (const [key, entry] of Object.entries(parsed.fields)) {
+    if (!isPlainObject(entry) || (!('value' in entry) && !isPlainObject(entry.surfaces))) {
+      return { ok: false, reason: `field "${key}" is not a { value, updatedAt } entry` };
+    }
+    const next = { updatedAt: parseStamp(entry.updatedAt) };
+    if ('value' in entry) next.value = entry.value;
+    if (isPlainObject(entry.surfaces)) {
+      next.surfaces = {};
+      for (const [surface, surfaceEntry] of Object.entries(entry.surfaces)) {
+        if (!SETTINGS_SURFACES.includes(surface) || !isPlainObject(surfaceEntry) || !('value' in surfaceEntry)) {
+          return { ok: false, reason: `field "${key}" has an invalid surface entry "${surface}"` };
+        }
+        next.surfaces[surface] = { value: surfaceEntry.value, updatedAt: parseStamp(surfaceEntry.updatedAt) };
+      }
+    }
+    fields[key] = next;
+  }
+  return { ok: true, fields };
+};
+
+export const serializePreferencesDocument = (fields) => JSON.stringify({ version: PREFERENCES_DOCUMENT_VERSION, fields }, null, 2);
+
+/**
+ * The plain key → value view of preference fields as one surface kind sees it:
+ * that surface's own value first, the base value otherwise; a key with neither
+ * is absent (the client keeps what it holds, or its default).
+ */
+export const flattenPreferences = (fields, surface = null) => {
+  const values = {};
+  for (const [key, entry] of Object.entries(fields)) {
+    const own = surface && entry.surfaces ? entry.surfaces[surface] : undefined;
+    if (own) {
+      values[key] = own.value;
+    } else if ('value' in entry) {
+      values[key] = entry.value;
+    }
+  }
+  return values;
+};
+
+/**
+ * The next preference fields for a merged document: every profile key it
+ * carries, stamped `now` when its value differs from what the file held and
+ * keeping the earlier stamp otherwise. Profile keys the document no longer
+ * carries are dropped (that is how a cleared key leaves the file).
+ *
+ * Per-surface keys: when the write comes from a surface kind (`surface`) and
+ * the key is among the keys that write changed (`changedKeys`), the value goes
+ * under `surfaces[surface]` and the base is left as it was; a per-surface key
+ * the write did not change keeps its whole entry (the document only carries
+ * that surface's resolved view of it). Without a surface (migrations, the
+ * one-time seed) the base is written.
+ */
+export const buildPreferencesFields = (previousFields, document, now, { surface = null, changedKeys = null } = {}) => {
+  const fields = {};
+  const changed = changedKeys ? new Set(changedKeys) : null;
+  for (const [key, value] of Object.entries(document)) {
+    if (value === undefined || !isProfileSettingsKey(key)) continue;
+    const previous = previousFields[key];
+    if (isPerSurfaceSettingsKey(key) && surface) {
+      if (changed && !changed.has(key)) {
+        if (previous) fields[key] = previous;
+        continue;
+      }
+      const previousOwn = previous?.surfaces?.[surface];
+      const own = previousOwn && sameValue(previousOwn.value, value) ? previousOwn : { value, updatedAt: now };
+      fields[key] = {
+        ...(previous ?? { updatedAt: 0 }),
+        surfaces: { ...(previous?.surfaces ?? {}), [surface]: own },
+      };
+      continue;
+    }
+    if (previous && 'value' in previous && sameValue(previous.value, value)) {
+      fields[key] = previous;
+    } else {
+      fields[key] = { ...(previous ?? {}), value, updatedAt: now };
+    }
+  }
+  return fields;
+};
+
+/**
+ * The part of a merged document that belongs in `settings.json`: everything
+ * that is not a profile key. Device keys older builds persisted stay in place
+ * as a read-once seed for clients; the write path never adds new ones.
+ */
+export const instancePartOf = (document) => {
+  const instance = {};
+  for (const [key, value] of Object.entries(document)) {
+    if (value === undefined || isProfileSettingsKey(key)) continue;
+    instance[key] = value;
+  }
+  return instance;
+};
+
+/** The profile keys of a document (the part `instancePartOf` leaves out). */
+export const profilePartOf = (document) => {
+  const profile = {};
+  for (const [key, value] of Object.entries(document)) {
+    if (value !== undefined && isProfileSettingsKey(key)) profile[key] = value;
+  }
+  return profile;
+};
+
+/**
+ * What `settings.json` holds after a write: the instance part plus a copy of
+ * the profile's base values. The copy is for builds that predate the split —
+ * they read only this file, so a rollback still finds the user's preferences.
+ * Current builds ignore it: `preferences.json` wins in the merged read.
+ */
+export const legacySettingsDocumentOf = (document, preferenceFields) => ({
+  ...instancePartOf(document),
+  ...flattenPreferences(preferenceFields),
+});
+
+/** The profile keys of a document, as they would seed a fresh preferences file. */
+export const seedPreferencesFrom = (document, now) => buildPreferencesFields({}, document, now);
+
+/**
+ * Synchronous merged read for server modules that consult one or two profile
+ * keys on a hot path (small-model resolution, goal/assist toggles). A missing
+ * or unreadable preferences file contributes nothing, and the caller's own
+ * default applies — the same "missing is not default" rule the clients use.
+ */
+export const readMergedSettingsSync = ({ fs, path, settingsFilePath }) => {
+  let settings = {};
+  try {
+    const parsed = JSON.parse(fs.readFileSync(settingsFilePath, 'utf8'));
+    if (isPlainObject(parsed)) settings = parsed;
+  } catch {
+    settings = {};
+  }
+  let preferences = {};
+  try {
+    const parsed = parsePreferencesDocument(fs.readFileSync(preferencesFilePathFor(settingsFilePath, path), 'utf8'));
+    if (parsed.ok) preferences = flattenPreferences(parsed.fields);
+  } catch {
+    preferences = {};
+  }
+  return { ...settings, ...preferences };
+};

package/server/lib/opencode/settings-helpers.js

@@ -1,5 +1,39 @@
+import { createRequire } from 'node:module';
+
 import { isAgentMemoryFeatureAvailable } from '../agent-memory/feature-flag.js';
 
+// Generated from packages/ui/src/lib/settings/registry.ts by
+// `bun run settings-registry:generate`; `registry.test.ts` fails when stale.
+// The server is plain ESM without a bundler, so the snapshot is read with
+// `createRequire` (import attributes differ across the Node versions we run on).
+const settingsRegistry = createRequire(import.meta.url)('./settings-registry.json');
+
+/**
+ * Whether a client may persist this key through PUT /api/config/settings:
+ * it must be a registry key, not a server-computed flag, not a device field
+ * that only lives in the browser, and not one the desktop shell writes itself.
+ */
+const isPersistableSettingsKey = (key) => {
+  const field = settingsRegistry.fields[key];
+  if (!field) return false;
+  if (field.computed || field.local) return false;
+  if (field.owner === 'desktop-shell') return false;
+  return true;
+};
+
+/** Keys accepted on write but never returned by a read. */
+const SECRET_SETTINGS_KEYS = Object.freeze(
+  Object.entries(settingsRegistry.fields)
+    .filter(([, field]) => field.secret === true)
+    .map(([key]) => key),
+);
+import {
+  DEFAULT_INPUT_HISTORY_LIMIT,
+  DEFAULT_INPUT_HISTORY_SCOPE,
+  isInputHistoryLimit,
+  isInputHistoryScope,
+} from './input-history-scope.js';
+
 export const createSettingsHelpers = (dependencies) => {
   const {
     normalizePathForPersistence,
@@ -12,7 +46,6 @@ export const createSettingsHelpers = (dependencies) => {
     normalizeManagedRemoteTunnelHostname,
     normalizeManagedRemoteTunnelPresets,
     normalizeManagedRemoteTunnelPresetTokens,
-    sanitizeTypographySizesPartial,
     normalizeStringArray,
     sanitizeModelRefs,
     sanitizeSkillCatalogs,
@@ -140,6 +173,12 @@ export const createSettingsHelpers = (dependencies) => {
     if (typeof candidate.themeVariant === 'string' && (candidate.themeVariant === 'light' || candidate.themeVariant === 'dark')) {
       result.themeVariant = candidate.themeVariant;
     }
+    if (typeof candidate.inputHistoryScope === 'string' && isInputHistoryScope(candidate.inputHistoryScope)) {
+      result.inputHistoryScope = candidate.inputHistoryScope;
+    }
+    if (isInputHistoryLimit(candidate.inputHistoryLimit)) {
+      result.inputHistoryLimit = candidate.inputHistoryLimit;
+    }
     if (typeof candidate.useSystemTheme === 'boolean') {
       result.useSystemTheme = candidate.useSystemTheme;
     }
@@ -191,6 +230,9 @@ export const createSettingsHelpers = (dependencies) => {
         ...new Set(candidate.workStatusHiddenSections.filter((entry) => typeof entry === 'string' && entry.length > 0)),
       ];
     }
+    if (typeof candidate.workStatusHiddenSectionsExplicit === 'boolean') {
+      result.workStatusHiddenSectionsExplicit = candidate.workStatusHiddenSectionsExplicit;
+    }
     if (typeof candidate.desktopLanAccessEnabled === 'boolean') {
       result.desktopLanAccessEnabled = candidate.desktopLanAccessEnabled;
     }
@@ -301,9 +343,6 @@ export const createSettingsHelpers = (dependencies) => {
     if (typeof candidate.monoFont === 'string' && candidate.monoFont.length > 0) {
       result.monoFont = candidate.monoFont;
     }
-    if (typeof candidate.markdownDisplayMode === 'string' && candidate.markdownDisplayMode.length > 0) {
-      result.markdownDisplayMode = candidate.markdownDisplayMode;
-    }
     if (typeof candidate.githubClientId === 'string') {
       const trimmed = candidate.githubClientId.trim();
       if (trimmed.length > 0) {
@@ -319,6 +358,45 @@ export const createSettingsHelpers = (dependencies) => {
     if (typeof candidate.showReasoningTraces === 'boolean') {
       result.showReasoningTraces = candidate.showReasoningTraces;
     }
+    if (typeof candidate.streamingAutoFollowEnabled === 'boolean') {
+      result.streamingAutoFollowEnabled = candidate.streamingAutoFollowEnabled;
+    }
+    if (typeof candidate.codeBlockLineWrap === 'boolean') {
+      result.codeBlockLineWrap = candidate.codeBlockLineWrap;
+    }
+    if (typeof candidate.autoSaveEnabled === 'boolean') {
+      result.autoSaveEnabled = candidate.autoSaveEnabled;
+    }
+    if (typeof candidate.diffWrapLines === 'boolean') {
+      result.diffWrapLines = candidate.diffWrapLines;
+    }
+    if (typeof candidate.persistChatDraft === 'boolean') {
+      result.persistChatDraft = candidate.persistChatDraft;
+    }
+    if (typeof candidate.allowPromptingSubagentSessions === 'boolean') {
+      result.allowPromptingSubagentSessions = candidate.allowPromptingSubagentSessions;
+    }
+    if (typeof candidate.showOpenCodeRestartConfirm === 'boolean') {
+      result.showOpenCodeRestartConfirm = candidate.showOpenCodeRestartConfirm;
+    }
+    if (typeof candidate.sessionTabsEnabled === 'boolean') {
+      result.sessionTabsEnabled = candidate.sessionTabsEnabled;
+    }
+    if (typeof candidate.largeTextPasteBehavior === 'string') {
+      const mode = candidate.largeTextPasteBehavior.trim();
+      if (mode === 'ask' || mode === 'attach' || mode === 'inline') {
+        result.largeTextPasteBehavior = mode;
+      }
+    }
+    if (typeof candidate.fileEditorKeymap === 'string') {
+      const mode = candidate.fileEditorKeymap.trim();
+      if (mode === 'default' || mode === 'vim') {
+        result.fileEditorKeymap = mode;
+      }
+    }
+    if (Array.isArray(candidate.providerOrder)) {
+      result.providerOrder = normalizeStringArray(candidate.providerOrder);
+    }
     if (typeof candidate.sessionRecapEnabled === 'boolean') {
       result.sessionRecapEnabled = candidate.sessionRecapEnabled;
     }
@@ -440,11 +518,6 @@ export const createSettingsHelpers = (dependencies) => {
       result.managedRemoteTunnelSelectedPresetId = id || undefined;
     }
 
-    const typography = sanitizeTypographySizesPartial(candidate.typographySizes);
-    if (typography) {
-      result.typographySizes = typography;
-    }
-
     if (typeof candidate.defaultModel === 'string') {
       const trimmed = candidate.defaultModel.trim();
       result.defaultModel = trimmed.length > 0 ? trimmed : undefined;
@@ -490,14 +563,6 @@ export const createSettingsHelpers = (dependencies) => {
       const trimmed = candidate.zenModel.trim();
       result.zenModel = trimmed.length > 0 ? trimmed : undefined;
     }
-    if (typeof candidate.gitProviderId === 'string') {
-      const trimmed = candidate.gitProviderId.trim();
-      result.gitProviderId = trimmed.length > 0 ? trimmed : undefined;
-    }
-    if (typeof candidate.gitModelId === 'string') {
-      const trimmed = candidate.gitModelId.trim();
-      result.gitModelId = trimmed.length > 0 ? trimmed : undefined;
-    }
     if (typeof candidate.pwaAppName === 'string') {
       result.pwaAppName = normalizePwaAppName(candidate.pwaAppName, undefined);
     }
@@ -510,15 +575,15 @@ export const createSettingsHelpers = (dependencies) => {
         result.mobileKeyboardMode = mode;
       }
     }
-    if (typeof candidate.toolCallExpansion === 'string') {
-      const mode = candidate.toolCallExpansion.trim();
-      if (mode === 'collapsed' || mode === 'activity' || mode === 'detailed' || mode === 'changes') {
-        result.toolCallExpansion = mode;
-      }
-    }
     if (typeof candidate.inputSpellcheckEnabled === 'boolean') {
       result.inputSpellcheckEnabled = candidate.inputSpellcheckEnabled;
     }
+    if (candidate.enterToSend === true || candidate.enterToSend === false) {
+      result.enterToSend = candidate.enterToSend;
+    }
+    if (candidate.enterToSendConfigured === true || candidate.enterToSendConfigured === false) {
+      result.enterToSendConfigured = candidate.enterToSendConfigured;
+    }
     if (typeof candidate.showOpenCodeUpdateNotifications === 'boolean') {
       result.showOpenCodeUpdateNotifications = candidate.showOpenCodeUpdateNotifications;
     }
@@ -601,9 +666,6 @@ export const createSettingsHelpers = (dependencies) => {
     if (typeof candidate.promptNavigatorEnabled === 'boolean') {
       result.promptNavigatorEnabled = candidate.promptNavigatorEnabled;
     }
-    if (typeof candidate.expandedEditorToolbar === 'boolean') {
-      result.expandedEditorToolbar = candidate.expandedEditorToolbar;
-    }
     if (typeof candidate.wideChatLayoutEnabled === 'boolean') {
       result.wideChatLayoutEnabled = candidate.wideChatLayoutEnabled;
     }
@@ -687,6 +749,12 @@ export const createSettingsHelpers = (dependencies) => {
         result.gitChangesViewMode = mode;
       }
     }
+    if (typeof candidate.toolJsonViewMode === 'string') {
+      const mode = candidate.toolJsonViewMode.trim();
+      if (mode === 'summary' || mode === 'formatted' || mode === 'raw') {
+        result.toolJsonViewMode = mode;
+      }
+    }
     if (typeof candidate.directoryShowHidden === 'boolean') {
       result.directoryShowHidden = candidate.directoryShowHidden;
     }
@@ -700,11 +768,6 @@ export const createSettingsHelpers = (dependencies) => {
       }
     }
 
-    // Message limit — single setting for fetch / trim / Load More chunk
-    if (typeof candidate.messageLimit === 'number' && Number.isFinite(candidate.messageLimit)) {
-      result.messageLimit = Math.max(10, Math.min(500, Math.round(candidate.messageLimit)));
-    }
-
     const skillCatalogs = sanitizeSkillCatalogs(candidate.skillCatalogs);
     if (skillCatalogs) {
       result.skillCatalogs = skillCatalogs;
@@ -888,6 +951,16 @@ export const createSettingsHelpers = (dependencies) => {
       }
     }
 
+    // The registry is the last word on what a client may persist: a key the
+    // code above still names but the registry no longer lists is dropped here,
+    // so the two cannot drift apart silently (settings-helpers.test.js checks
+    // the other direction).
+    for (const key of Object.keys(result)) {
+      if (!isPersistableSettingsKey(key)) {
+        delete result[key];
+      }
+    }
+
     return result;
   };
 
@@ -898,13 +971,6 @@ export const createSettingsHelpers = (dependencies) => {
         ? current.securityScopedBookmarks
         : [];
 
-    const nextTypographySizes = changes.typographySizes
-      ? {
-          ...(current.typographySizes || {}),
-          ...changes.typographySizes
-        }
-      : current.typographySizes;
-
     const next = {
       ...current,
       ...changes,
@@ -913,7 +979,6 @@ export const createSettingsHelpers = (dependencies) => {
           baseBookmarks.filter((entry) => typeof entry === 'string' && entry.length > 0)
         )
       ),
-      typographySizes: nextTypographySizes
     };
 
     return next;
@@ -921,30 +986,37 @@ export const createSettingsHelpers = (dependencies) => {
 
   const formatSettingsResponse = (settings) => {
     const sanitized = sanitizeSettingsUpdate(settings);
-    delete sanitized.managedRemoteTunnelToken;
+    for (const key of SECRET_SETTINGS_KEYS) {
+      delete sanitized[key];
+    }
     const bookmarks = normalizeStringArray(settings.securityScopedBookmarks);
     const hasManagedRemoteTunnelToken = typeof settings?.managedRemoteTunnelToken === 'string' && settings.managedRemoteTunnelToken.trim().length > 0;
+    const hasDesktopUiPassword = typeof settings?.desktopUiPassword === 'string' && settings.desktopUiPassword.trim().length > 0;
     const pwaAppName = normalizePwaAppName(settings?.pwaAppName, '');
     const pwaOrientation = normalizePwaOrientation(settings?.pwaOrientation, 'system');
     const mobileKeyboardMode = normalizeMobileKeyboardMode(settings?.mobileKeyboardMode, 'native');
+    const inputHistoryScope = sanitized.inputHistoryScope ?? DEFAULT_INPUT_HISTORY_SCOPE;
+    const inputHistoryLimit = sanitized.inputHistoryLimit ?? DEFAULT_INPUT_HISTORY_LIMIT;
 
     return {
       ...sanitized,
       hasManagedRemoteTunnelToken,
+      hasDesktopUiPassword,
       // Tells the client whether agent memory exists in this build at all, so
       // its settings row and panel tab can be absent rather than merely off.
       agentMemoryFeatureAvailable: isAgentMemoryFeatureAvailable(),
       ...(pwaAppName ? { pwaAppName } : {}),
       pwaOrientation,
       mobileKeyboardMode,
+      inputHistoryScope,
+      inputHistoryLimit,
       securityScopedBookmarks: bookmarks,
       pinnedDirectories: normalizeStringArray(settings.pinnedDirectories),
-      typographySizes: sanitizeTypographySizesPartial(settings.typographySizes),
-      ...(process.env.OPENCHAMBER_RUNTIME === 'desktop'
+      ...(process.env.AIWORKER_RUNTIME === 'desktop'
         ? {
-            desktopLanAccessActive: process.env.OPENCHAMBER_DESKTOP_LAN_ACCESS_ACTIVE === 'true',
+            desktopLanAccessActive: process.env.AIWORKER_DESKTOP_LAN_ACCESS_ACTIVE === 'true',
             desktopLanAccessBlockedReason:
-              process.env.OPENCHAMBER_DESKTOP_LAN_ACCESS_BLOCKED_REASON === 'missing-password'
+              process.env.AIWORKER_DESKTOP_LAN_ACCESS_BLOCKED_REASON === 'missing-password'
                 ? 'missing-password'
                 : null,
           }