fix(config): strip UTF-8 BOM in preset-switch and update-checker readers (#1028)

Author: MyGO-Mujica

src/hooks/auto-update-checker/checker.test.ts

@@ -108,6 +108,49 @@ describe('auto-update-checker/checker', () => {
       statSpy.mockRestore();
       readSpy.mockRestore();
     });
+
+    test('returns version from a BOM-prefixed config', async () => {
+      const existsSpy = spyOn(fs, 'existsSync').mockImplementation(
+        (p: string) => {
+          if (p.includes('opencode.json')) return true;
+          if (p.includes('package.json')) return true;
+          return false;
+        },
+      );
+      const statSpy = spyOn(fs, 'statSync').mockImplementation(
+        () =>
+          ({
+            isDirectory: () => true,
+          }) as unknown as fs.Stats,
+      );
+      const readSpy = spyOn(fs, 'readFileSync').mockImplementation(
+        (p: string) => {
+          if (p.includes('opencode.json')) {
+            // A UTF-8 BOM (RFC 8259 permits one) must not break JSON.parse.
+            return `\uFEFF${JSON.stringify({
+              plugin: ['file:///dev/oh-my-opencode-slim'],
+            })}`;
+          }
+          if (p.includes('package.json')) {
+            return JSON.stringify({
+              name: 'oh-my-opencode-slim',
+              version: '1.2.3-dev',
+            });
+          }
+          return '';
+        },
+      );
+
+      const { getLocalDevVersion } = await import(
+        `./checker?test=${importCounter++}`
+      );
+
+      expect(getLocalDevVersion('/test')).toBe('1.2.3-dev');
+
+      existsSpy.mockRestore();
+      statSpy.mockRestore();
+      readSpy.mockRestore();
+    });
   });
 
   describe('findPluginEntry', () => {
@@ -135,6 +178,28 @@ describe('auto-update-checker/checker', () => {
       readSpy.mockRestore();
     });
 
+    test('detects entry in a BOM-prefixed config', async () => {
+      const existsSpy = spyOn(fs, 'existsSync').mockImplementation(
+        (p: string) => p.includes('opencode.json'),
+      );
+      const readSpy = spyOn(fs, 'readFileSync').mockReturnValue(
+        `\uFEFF${JSON.stringify({
+          plugin: ['oh-my-opencode-slim'],
+        })}`,
+      );
+
+      const { findPluginEntry } = await import(
+        `./checker?test=${importCounter++}`
+      );
+
+      const entry = findPluginEntry('/test');
+      expect(entry).not.toBeNull();
+      expect(entry?.entry).toBe('oh-my-opencode-slim');
+
+      existsSpy.mockRestore();
+      readSpy.mockRestore();
+    });
+
     test('detects pinned version entry', async () => {
       const existsSpy = spyOn(fs, 'existsSync').mockImplementation(
         (p: string) => p.includes('opencode.json'),

src/hooks/auto-update-checker/checker.ts

@@ -346,7 +346,11 @@ function getLocalDevPath(directory: string): string | null {
   for (const configPath of getConfigPaths(directory)) {
     try {
       if (!fs.existsSync(configPath)) continue;
-      const content = fs.readFileSync(configPath, 'utf-8');
+      // Strip a UTF-8 BOM (RFC 8259 permits one); JSON.parse would otherwise
+      // fail with "Unrecognized token" and skip the local dev path.
+      const content = fs
+        .readFileSync(configPath, 'utf-8')
+        .replace(/^\uFEFF/, '');
       const config = JSON.parse(stripJsonComments(content)) as OpencodeConfig;
       const plugins = getPluginEntries(config);
 
@@ -436,7 +440,11 @@ export function findPluginEntry(directory: string): PluginEntryInfo | null {
   for (const configPath of getConfigPaths(directory)) {
     try {
       if (!fs.existsSync(configPath)) continue;
-      const content = fs.readFileSync(configPath, 'utf-8');
+      // Strip a UTF-8 BOM (RFC 8259 permits one); JSON.parse would otherwise
+      // fail with "Unrecognized token" and the plugin entry would be missed.
+      const content = fs
+        .readFileSync(configPath, 'utf-8')
+        .replace(/^\uFEFF/, '');
       const config = JSON.parse(stripJsonComments(content)) as OpencodeConfig;
       const plugins = getPluginEntries(config);
 

src/tools/preset-switch.test.ts

@@ -150,6 +150,39 @@ describe('switchPresetOnDisk', () => {
     });
   });
 
+  test('persists preset name when the user config has a UTF-8 BOM', () => {
+    const configDir = path.join(tempDir, 'opencode-config');
+    fs.mkdirSync(configDir, { recursive: true });
+    process.env.OPENCODE_CONFIG_DIR = configDir;
+
+    const configPath = path.join(configDir, 'oh-my-opencode-slim.json');
+    fs.writeFileSync(
+      configPath,
+      `\uFEFF${JSON.stringify({
+        preset: 'old',
+        agents: { oracle: { model: 'old-model' } },
+      })}`,
+    );
+
+    const config: PluginConfig = {
+      presets: {
+        cheap: { orchestrator: { model: 'anthropic/claude-3.5-haiku' } },
+      },
+    };
+
+    const result = switchPresetOnDisk(tempDir, 'cheap', config);
+    expect(result.ok).toBe(true);
+
+    // The BOM is stripped on read, so the preset name is persisted; the
+    // rewritten file is plain JSON that parses cleanly.
+    const persisted = JSON.parse(fs.readFileSync(configPath, 'utf-8')) as {
+      preset?: string;
+      agents?: Record<string, unknown>;
+    };
+    expect(persisted.preset).toBe('cheap');
+    expect(persisted.agents).toEqual({ oracle: { model: 'old-model' } });
+  });
+
   test('resolves legacy alias keys (explore → explorer)', () => {
     const config: PluginConfig = {
       presets: {
@@ -287,6 +320,36 @@ describe('writePreset', () => {
     expect(persisted.preset).toBe('old');
   });
 
+  test('reads a user config with a UTF-8 BOM before writing', () => {
+    const configDir = path.join(tempDir, 'opencode-config');
+    fs.mkdirSync(configDir, { recursive: true });
+    process.env.OPENCODE_CONFIG_DIR = configDir;
+    const configPath = path.join(configDir, 'oh-my-opencode-slim.json');
+    fs.writeFileSync(
+      configPath,
+      `\uFEFF${JSON.stringify({
+        preset: 'old',
+        presets: { existing: { oracle: { model: 'a' } } },
+      })}`,
+    );
+
+    const ok = writePreset(tempDir, 'scout', {
+      explorer: { model: 'openai/gpt-5.6-luna' },
+    });
+
+    expect(ok).toBe(true);
+    const persisted = JSON.parse(fs.readFileSync(configPath, 'utf-8')) as {
+      preset?: string;
+      presets?: Record<string, unknown>;
+    };
+    // Existing fields survived, proving the BOM-prefixed file was parsed
+    expect(persisted.preset).toBe('old');
+    expect(persisted.presets?.existing).toEqual({ oracle: { model: 'a' } });
+    expect(persisted.presets?.scout).toEqual({
+      explorer: { model: 'openai/gpt-5.6-luna' },
+    });
+  });
+
   test('overwrites an existing preset of the same name', () => {
     const configDir = path.join(tempDir, 'opencode-config');
     fs.mkdirSync(configDir, { recursive: true });

src/tools/preset-switch.ts

@@ -165,7 +165,9 @@ function persistPresetName(directory: string, presetName: string): void {
   try {
     const { userConfigPath } = findPluginConfigPaths(directory);
     if (!userConfigPath) return;
-    const raw = fs.readFileSync(userConfigPath, 'utf-8');
+    // Strip a UTF-8 BOM (RFC 8259 permits one); JSON.parse would otherwise
+    // fail with "Unrecognized token" and the preset would not be persisted.
+    const raw = fs.readFileSync(userConfigPath, 'utf-8').replace(/^\uFEFF/, '');
     const persisted = JSON.parse(stripJsonComments(raw)) as Record<
       string,
       unknown
@@ -186,7 +188,9 @@ function readUserConfig(directory: string): Record<string, unknown> | null {
   try {
     const { userConfigPath } = findPluginConfigPaths(directory);
     if (!userConfigPath) return null;
-    const raw = fs.readFileSync(userConfigPath, 'utf-8');
+    // Strip a UTF-8 BOM (RFC 8259 permits one); JSON.parse would otherwise
+    // fail with "Unrecognized token" and the preset name would be lost.
+    const raw = fs.readFileSync(userConfigPath, 'utf-8').replace(/^\uFEFF/, '');
     return JSON.parse(stripJsonComments(raw)) as Record<string, unknown>;
   } catch {
     return null;