opencode-morphllm 0.0.6 → 0.0.8

package/dist/shared/config.js

@@ -3,80 +3,78 @@ import { join } from 'node:path';
 import { getOpenCodeConfigDir } from './opencode-config-dir';
 const MORPH_PLUGIN_NAME = 'morph';
 export function getMorphPluginConfigPath() {
-  const configDir = getOpenCodeConfigDir({ binary: 'opencode' });
-  return join(configDir, `${MORPH_PLUGIN_NAME}.json`);
+    const configDir = getOpenCodeConfigDir({ binary: 'opencode' });
+    return join(configDir, `${MORPH_PLUGIN_NAME}.json`);
 }
 function parseJsonc(content) {
-  try {
-    // A simple JSONC parser that removes comments
-    const cleanedContent = content.replace(/\/\*[\s\S]*?\*\/|\/\/.*/g, '');
-    return JSON.parse(cleanedContent);
-  } catch {
-    return null;
-  }
+    try {
+        // A simple JSONC parser that removes comments
+        const cleanedContent = content.replace(/\/\*[\s\S]*?\*\/|\/\/.*/g, '');
+        return JSON.parse(cleanedContent);
+    }
+    catch {
+        return null;
+    }
 }
 export function loadMorphPluginConfig() {
-  const jsoncPath = getMorphPluginConfigPath().replace('.json', '.jsonc');
-  const jsonPath = getMorphPluginConfigPath();
-  if (existsSync(jsoncPath)) {
-    try {
-      const content = readFileSync(jsoncPath, 'utf-8');
-      return parseJsonc(content);
-    } catch {
-      return null;
+    const jsoncPath = getMorphPluginConfigPath().replace('.json', '.jsonc');
+    const jsonPath = getMorphPluginConfigPath();
+    if (existsSync(jsoncPath)) {
+        try {
+            const content = readFileSync(jsoncPath, 'utf-8');
+            return parseJsonc(content);
+        }
+        catch {
+            return null;
+        }
     }
-  }
-  if (existsSync(jsonPath)) {
-    try {
-      const content = readFileSync(jsonPath, 'utf-8');
-      return JSON.parse(content);
-    } catch {
-      return null;
+    if (existsSync(jsonPath)) {
+        try {
+            const content = readFileSync(jsonPath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch {
+            return null;
+        }
     }
-  }
-  return null;
+    return null;
 }
-export function loadMorphPluginConfigWithProjectOverride(
-  projectDir = process.cwd()
-) {
-  const userConfig = loadMorphPluginConfig() ?? {};
-  const projectBasePath = join(projectDir, '.opencode', MORPH_PLUGIN_NAME);
-  const projectJsoncPath = `${projectBasePath}.jsonc`;
-  const projectJsonPath = `${projectBasePath}.json`;
-  let projectConfig = {};
-  if (existsSync(projectJsoncPath)) {
-    try {
-      const content = readFileSync(projectJsoncPath, 'utf-8');
-      projectConfig = parseJsonc(content) ?? {};
-    } catch {
-      // Ignore parse errors
+export function loadMorphPluginConfigWithProjectOverride(projectDir = process.cwd()) {
+    const userConfig = loadMorphPluginConfig() ?? {};
+    const projectBasePath = join(projectDir, '.opencode', MORPH_PLUGIN_NAME);
+    const projectJsoncPath = `${projectBasePath}.jsonc`;
+    const projectJsonPath = `${projectBasePath}.json`;
+    let projectConfig = {};
+    if (existsSync(projectJsoncPath)) {
+        try {
+            const content = readFileSync(projectJsoncPath, 'utf-8');
+            projectConfig = parseJsonc(content) ?? {};
+        }
+        catch {
+            // Ignore parse errors
+        }
     }
-  } else if (existsSync(projectJsonPath)) {
-    try {
-      const content = readFileSync(projectJsonPath, 'utf-8');
-      projectConfig = JSON.parse(content);
-    } catch {
-      // Ignore parse errors
+    else if (existsSync(projectJsonPath)) {
+        try {
+            const content = readFileSync(projectJsonPath, 'utf-8');
+            projectConfig = JSON.parse(content);
+        }
+        catch {
+            // Ignore parse errors
+        }
     }
-  }
-  return { ...userConfig, ...projectConfig };
+    return { ...userConfig, ...projectConfig };
 }
 const config = loadMorphPluginConfigWithProjectOverride();
 const routerConfigs = config.MORPH_ROUTER_CONFIGS || {};
 export const API_KEY = config.MORPH_API_KEY || '';
-export const MORPH_MODEL_EASY =
-  routerConfigs.MORPH_MODEL_EASY || config.MORPH_MODEL_EASY || '';
-export const MORPH_MODEL_MEDIUM =
-  routerConfigs.MORPH_MODEL_MEDIUM || config.MORPH_MODEL_MEDIUM || '';
-export const MORPH_MODEL_HARD =
-  routerConfigs.MORPH_MODEL_HARD || config.MORPH_MODEL_HARD || '';
-export const MORPH_MODEL_DEFAULT =
-  routerConfigs.MORPH_MODEL_DEFAULT ||
-  config.MORPH_MODEL_DEFAULT ||
-  MORPH_MODEL_MEDIUM;
-export const MORPH_ROUTER_ENABLED =
-  routerConfigs.MORPH_ROUTER_ENABLED ?? config.MORPH_ROUTER_ENABLED ?? true;
-export const MORPH_ROUTER_ONLY_FIRST_MESSAGE =
-  routerConfigs.MORPH_ROUTER_ONLY_FIRST_MESSAGE ??
-  config.MORPH_ROUTER_ONLY_FIRST_MESSAGE ??
-  false;
+export const MORPH_MODEL_EASY = routerConfigs.MORPH_MODEL_EASY || config.MORPH_MODEL_EASY || '';
+export const MORPH_MODEL_MEDIUM = routerConfigs.MORPH_MODEL_MEDIUM || config.MORPH_MODEL_MEDIUM || '';
+export const MORPH_MODEL_HARD = routerConfigs.MORPH_MODEL_HARD || config.MORPH_MODEL_HARD || '';
+export const MORPH_MODEL_DEFAULT = routerConfigs.MORPH_MODEL_DEFAULT ||
+    config.MORPH_MODEL_DEFAULT ||
+    MORPH_MODEL_MEDIUM;
+export const MORPH_ROUTER_ENABLED = routerConfigs.MORPH_ROUTER_ENABLED ?? config.MORPH_ROUTER_ENABLED ?? true;
+export const MORPH_ROUTER_PROMPT_CACHING_AWARE = routerConfigs.MORPH_ROUTER_PROMPT_CACHING_AWARE ??
+    config.MORPH_ROUTER_PROMPT_CACHING_AWARE ??
+    false;

package/dist/shared/config.test.js

@@ -1,204 +1,201 @@
-import {
-  describe,
-  it,
-  expect,
-  beforeEach,
-  vi,
-  beforeAll,
-  afterAll,
-} from 'bun:test';
-import { existsSync, writeFileSync, rmSync, mkdirSync } from 'node:fs';
+import { describe, it, expect, beforeEach, beforeAll, afterAll, } from 'bun:test';
+import { existsSync, writeFileSync, rmSync, mkdirSync, } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
-// Mock the opencode-config-dir module before importing config
-const mockConfigDir = join(tmpdir(), 'mock-opencode-config-test');
+import { env } from 'node:process';
+// Use a real temporary directory for testing - no mocking needed
+const mockConfigDir = join(tmpdir(), 'mock-morph-config-test');
 const mockMorphJson = join(mockConfigDir, 'morph.json');
 const mockMorphJsonc = join(mockConfigDir, 'morph.jsonc');
-vi.mock('./opencode-config-dir', () => ({
-  getOpenCodeConfigDir: vi.fn(() => mockConfigDir),
-}));
-import {
-  getMorphPluginConfigPath,
-  loadMorphPluginConfig,
-  loadMorphPluginConfigWithProjectOverride,
-} from './config';
+// Save original environment
+let originalEnv;
+import { getMorphPluginConfigPath, loadMorphPluginConfig, loadMorphPluginConfigWithProjectOverride, } from './config';
 describe('config.ts', () => {
-  beforeAll(() => {
-    // Create mock config directory
-    if (!existsSync(mockConfigDir)) {
-      mkdirSync(mockConfigDir, { recursive: true });
-    }
-  });
-  afterAll(() => {
-    // Cleanup
-    try {
-      if (existsSync(mockMorphJson)) rmSync(mockMorphJson);
-      if (existsSync(mockMorphJsonc)) rmSync(mockMorphJsonc);
-      if (existsSync(mockConfigDir)) rmSync(mockConfigDir, { recursive: true });
-    } catch {
-      // Ignore cleanup errors
-    }
-  });
-  beforeEach(() => {
-    // Clean up any existing config files before each test
-    try {
-      if (existsSync(mockMorphJson)) rmSync(mockMorphJson);
-      if (existsSync(mockMorphJsonc)) rmSync(mockMorphJsonc);
-    } catch {
-      // Ignore cleanup errors
-    }
-  });
-  describe('getMorphPluginConfigPath', () => {
-    it('should return path to morph.json in config directory', () => {
-      const path = getMorphPluginConfigPath();
-      expect(path).toContain('morph.json');
-      expect(path).toContain(mockConfigDir);
+    beforeAll(() => {
+        // Save original environment and set custom config dir
+        originalEnv = {
+            OPENCODE_CONFIG_DIR: env.OPENCODE_CONFIG_DIR,
+        };
+        env.OPENCODE_CONFIG_DIR = mockConfigDir;
+        // Create mock config directory
+        if (!existsSync(mockConfigDir)) {
+            mkdirSync(mockConfigDir, { recursive: true });
+        }
+    });
+    afterAll(() => {
+        // Restore original environment
+        if (originalEnv.OPENCODE_CONFIG_DIR !== undefined) {
+            env.OPENCODE_CONFIG_DIR = originalEnv.OPENCODE_CONFIG_DIR;
+        }
+        else {
+            delete env.OPENCODE_CONFIG_DIR;
+        }
+        // Cleanup
+        try {
+            if (existsSync(mockMorphJson))
+                rmSync(mockMorphJson);
+            if (existsSync(mockMorphJsonc))
+                rmSync(mockMorphJsonc);
+            if (existsSync(mockConfigDir))
+                rmSync(mockConfigDir, { recursive: true });
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    });
+    beforeEach(() => {
+        // Clean up any existing config files before each test
+        try {
+            if (existsSync(mockMorphJson))
+                rmSync(mockMorphJson);
+            if (existsSync(mockMorphJsonc))
+                rmSync(mockMorphJsonc);
+        }
+        catch {
+            // Ignore cleanup errors
+        }
     });
-  });
-  describe('loadMorphPluginConfig', () => {
-    it('should return null when no config files exist', () => {
-      const result = loadMorphPluginConfig();
-      expect(result).toBeNull();
+    describe('getMorphPluginConfigPath', () => {
+        it('should return path to morph.json in config directory', () => {
+            const path = getMorphPluginConfigPath();
+            expect(path).toContain('morph.json');
+            expect(path).toContain(mockConfigDir);
+        });
     });
-    it('should load config from .jsonc file', () => {
-      const content = `{
+    describe('loadMorphPluginConfig', () => {
+        it('should return null when no config files exist', () => {
+            const result = loadMorphPluginConfig();
+            expect(result).toBeNull();
+        });
+        it('should load config from .jsonc file', () => {
+            const content = `{
         "MORPH_API_KEY": "test-key-123",
         "MORPH_ROUTER_ENABLED": false
       }`;
-      writeFileSync(mockMorphJsonc, content);
-      const result = loadMorphPluginConfig();
-      expect(result).not.toBeNull();
-      expect(result?.MORPH_API_KEY).toBe('test-key-123');
-      expect(result?.MORPH_ROUTER_ENABLED).toBe(false);
-    });
-    it('should load config from .json file', () => {
-      const content = JSON.stringify({
-        MORPH_API_KEY: 'json-key-456',
-        MORPH_MODEL_EASY: 'provider/model-easy',
-      });
-      writeFileSync(mockMorphJson, content);
-      const result = loadMorphPluginConfig();
-      expect(result).not.toBeNull();
-      expect(result?.MORPH_API_KEY).toBe('json-key-456');
-      expect(result?.MORPH_MODEL_EASY).toBe('provider/model-easy');
-    });
-    it('should prefer .jsonc over .json when both exist', () => {
-      const jsoncContent = '{"MORPH_API_KEY": "from-jsonc"}';
-      const jsonContent = '{"MORPH_API_KEY": "from-json"}';
-      writeFileSync(mockMorphJsonc, jsoncContent);
-      writeFileSync(mockMorphJson, jsonContent);
-      const result = loadMorphPluginConfig();
-      expect(result?.MORPH_API_KEY).toBe('from-jsonc');
-    });
-    it('should return null for invalid .jsonc content', () => {
-      writeFileSync(mockMorphJsonc, 'invalid json content');
-      const result = loadMorphPluginConfig();
-      expect(result).toBeNull();
-    });
-    it('should return null for invalid .json content', () => {
-      writeFileSync(mockMorphJson, 'invalid json content');
-      const result = loadMorphPluginConfig();
-      expect(result).toBeNull();
-    });
-    it('should handle all MORPH config fields', () => {
-      const content = JSON.stringify({
-        MORPH_API_KEY: 'api-key',
-        MORPH_ROUTER_ENABLED: true,
-        MORPH_MODEL_EASY: 'easy/provider/model',
-        MORPH_MODEL_MEDIUM: 'medium/provider/model',
-        MORPH_MODEL_HARD: 'hard/provider/model',
-        MORPH_MODEL_DEFAULT: 'default/provider/model',
-      });
-      writeFileSync(mockMorphJson, content);
-      const result = loadMorphPluginConfig();
-      expect(result).toEqual({
-        MORPH_API_KEY: 'api-key',
-        MORPH_ROUTER_ENABLED: true,
-        MORPH_MODEL_EASY: 'easy/provider/model',
-        MORPH_MODEL_MEDIUM: 'medium/provider/model',
-        MORPH_MODEL_HARD: 'hard/provider/model',
-        MORPH_MODEL_DEFAULT: 'default/provider/model',
-      });
-    });
-    it('should handle nested MORPH_ROUTER_CONFIGS', () => {
-      const content = JSON.stringify({
-        MORPH_API_KEY: 'api-key',
-        MORPH_ROUTER_CONFIGS: {
-          MORPH_ROUTER_ENABLED: true,
-          MORPH_MODEL_EASY: 'easy/provider/model',
-          MORPH_MODEL_MEDIUM: 'medium/provider/model',
-          MORPH_MODEL_HARD: 'hard/provider/model',
-          MORPH_MODEL_DEFAULT: 'default/provider/model',
-        },
-      });
-      writeFileSync(mockMorphJson, content);
-      const result = loadMorphPluginConfig();
-      expect(result?.MORPH_API_KEY).toBe('api-key');
-      expect(result?.MORPH_ROUTER_CONFIGS).toEqual({
-        MORPH_ROUTER_ENABLED: true,
-        MORPH_MODEL_EASY: 'easy/provider/model',
-        MORPH_MODEL_MEDIUM: 'medium/provider/model',
-        MORPH_MODEL_HARD: 'hard/provider/model',
-        MORPH_MODEL_DEFAULT: 'default/provider/model',
-      });
-    });
-  });
-  describe('loadMorphPluginConfigWithProjectOverride', () => {
-    it('should return empty object when no config exists', () => {
-      const result =
-        loadMorphPluginConfigWithProjectOverride('/non-existent-path');
-      expect(result).toEqual({});
-    });
-    it('should merge user config with project config', () => {
-      // Create user config
-      writeFileSync(
-        mockMorphJson,
-        JSON.stringify({
-          MORPH_API_KEY: 'user-api-key',
-          MORPH_MODEL_EASY: 'user-easy-model',
-        })
-      );
-      // Create project config directory
-      const projectDir = join(tmpdir(), 'test-project');
-      const projectConfigDir = join(projectDir, '.opencode');
-      const projectConfigPath = join(projectConfigDir, 'morph.json');
-      mkdirSync(projectConfigDir, { recursive: true });
-      writeFileSync(
-        projectConfigPath,
-        JSON.stringify({
-          MORPH_API_KEY: 'project-api-key',
-          MORPH_MODEL_HARD: 'project-hard-model',
-        })
-      );
-      const result = loadMorphPluginConfigWithProjectOverride(projectDir);
-      // Project config should override user config
-      expect(result.MORPH_API_KEY).toBe('project-api-key');
-      expect(result.MORPH_MODEL_EASY).toBe('user-easy-model');
-      expect(result.MORPH_MODEL_HARD).toBe('project-hard-model');
+            writeFileSync(mockMorphJsonc, content);
+            const result = loadMorphPluginConfig();
+            expect(result).not.toBeNull();
+            expect(result?.MORPH_API_KEY).toBe('test-key-123');
+            expect(result?.MORPH_ROUTER_ENABLED).toBe(false);
+        });
+        it('should load config from .json file', () => {
+            const content = JSON.stringify({
+                MORPH_API_KEY: 'json-key-456',
+                MORPH_MODEL_EASY: 'provider/model-easy',
+            });
+            writeFileSync(mockMorphJson, content);
+            const result = loadMorphPluginConfig();
+            expect(result).not.toBeNull();
+            expect(result?.MORPH_API_KEY).toBe('json-key-456');
+            expect(result?.MORPH_MODEL_EASY).toBe('provider/model-easy');
+        });
+        it('should prefer .jsonc over .json when both exist', () => {
+            const jsoncContent = '{"MORPH_API_KEY": "from-jsonc"}';
+            const jsonContent = '{"MORPH_API_KEY": "from-json"}';
+            writeFileSync(mockMorphJsonc, jsoncContent);
+            writeFileSync(mockMorphJson, jsonContent);
+            const result = loadMorphPluginConfig();
+            expect(result?.MORPH_API_KEY).toBe('from-jsonc');
+        });
+        it('should return null for invalid .jsonc content', () => {
+            writeFileSync(mockMorphJsonc, 'invalid json content');
+            const result = loadMorphPluginConfig();
+            expect(result).toBeNull();
+        });
+        it('should return null for invalid .json content', () => {
+            writeFileSync(mockMorphJson, 'invalid json content');
+            const result = loadMorphPluginConfig();
+            expect(result).toBeNull();
+        });
+        it('should handle all MORPH config fields', () => {
+            const content = JSON.stringify({
+                MORPH_API_KEY: 'api-key',
+                MORPH_ROUTER_ENABLED: true,
+                MORPH_MODEL_EASY: 'easy/provider/model',
+                MORPH_MODEL_MEDIUM: 'medium/provider/model',
+                MORPH_MODEL_HARD: 'hard/provider/model',
+                MORPH_MODEL_DEFAULT: 'default/provider/model',
+            });
+            writeFileSync(mockMorphJson, content);
+            const result = loadMorphPluginConfig();
+            expect(result).toEqual({
+                MORPH_API_KEY: 'api-key',
+                MORPH_ROUTER_ENABLED: true,
+                MORPH_MODEL_EASY: 'easy/provider/model',
+                MORPH_MODEL_MEDIUM: 'medium/provider/model',
+                MORPH_MODEL_HARD: 'hard/provider/model',
+                MORPH_MODEL_DEFAULT: 'default/provider/model',
+            });
+        });
+        it('should handle nested MORPH_ROUTER_CONFIGS', () => {
+            const content = JSON.stringify({
+                MORPH_API_KEY: 'api-key',
+                MORPH_ROUTER_CONFIGS: {
+                    MORPH_ROUTER_ENABLED: true,
+                    MORPH_MODEL_EASY: 'easy/provider/model',
+                    MORPH_MODEL_MEDIUM: 'medium/provider/model',
+                    MORPH_MODEL_HARD: 'hard/provider/model',
+                    MORPH_MODEL_DEFAULT: 'default/provider/model',
+                },
+            });
+            writeFileSync(mockMorphJson, content);
+            const result = loadMorphPluginConfig();
+            expect(result?.MORPH_API_KEY).toBe('api-key');
+            expect(result?.MORPH_ROUTER_CONFIGS).toEqual({
+                MORPH_ROUTER_ENABLED: true,
+                MORPH_MODEL_EASY: 'easy/provider/model',
+                MORPH_MODEL_MEDIUM: 'medium/provider/model',
+                MORPH_MODEL_HARD: 'hard/provider/model',
+                MORPH_MODEL_DEFAULT: 'default/provider/model',
+            });
+        });
     });
-    it('should handle project .jsonc config', () => {
-      // Create user config
-      writeFileSync(
-        mockMorphJson,
-        JSON.stringify({
-          MORPH_API_KEY: 'user-key',
-        })
-      );
-      // Create project config with .jsonc
-      const projectDir = join(tmpdir(), 'test-project2');
-      const projectConfigDir = join(projectDir, '.opencode');
-      const projectConfigPath = join(projectConfigDir, 'morph.jsonc');
-      mkdirSync(projectConfigDir, { recursive: true });
-      const jsoncContent = `
+    describe('loadMorphPluginConfigWithProjectOverride', () => {
+        it('should return empty object when no config exists', () => {
+            const result = loadMorphPluginConfigWithProjectOverride('/non-existent-path');
+            expect(result).toEqual({});
+        });
+        it('should merge user config with project config', () => {
+            // Create user config
+            writeFileSync(mockMorphJson, JSON.stringify({
+                MORPH_API_KEY: 'user-api-key',
+                MORPH_MODEL_EASY: 'user-easy-model',
+            }));
+            // Create project config directory
+            const projectDir = join(tmpdir(), 'test-project');
+            const projectConfigDir = join(projectDir, '.opencode');
+            const projectConfigPath = join(projectConfigDir, 'morph.json');
+            mkdirSync(projectConfigDir, { recursive: true });
+            writeFileSync(projectConfigPath, JSON.stringify({
+                MORPH_API_KEY: 'project-api-key',
+                MORPH_MODEL_HARD: 'project-hard-model',
+            }));
+            const result = loadMorphPluginConfigWithProjectOverride(projectDir);
+            // Project config should override user config
+            expect(result.MORPH_API_KEY).toBe('project-api-key');
+            expect(result.MORPH_MODEL_EASY).toBe('user-easy-model');
+            expect(result.MORPH_MODEL_HARD).toBe('project-hard-model');
+        });
+        it('should handle project .jsonc config', () => {
+            // Create user config
+            writeFileSync(mockMorphJson, JSON.stringify({
+                MORPH_API_KEY: 'user-key',
+            }));
+            // Create project config with .jsonc
+            const projectDir = join(tmpdir(), 'test-project2');
+            const projectConfigDir = join(projectDir, '.opencode');
+            const projectConfigPath = join(projectConfigDir, 'morph.jsonc');
+            mkdirSync(projectConfigDir, { recursive: true });
+            const jsoncContent = `
         // Project config with comments
         {
           "MORPH_MODEL_MEDIUM": "project-medium-model"
         }
       `;
-      writeFileSync(projectConfigPath, jsoncContent);
-      const result = loadMorphPluginConfigWithProjectOverride(projectDir);
-      expect(result.MORPH_API_KEY).toBe('user-key');
-      expect(result.MORPH_MODEL_MEDIUM).toBe('project-medium-model');
+            writeFileSync(projectConfigPath, jsoncContent);
+            const result = loadMorphPluginConfigWithProjectOverride(projectDir);
+            expect(result.MORPH_API_KEY).toBe('user-key');
+            expect(result.MORPH_MODEL_MEDIUM).toBe('project-medium-model');
+        });
     });
-  });
 });

package/dist/shared/opencode-config-dir.d.ts

@@ -1,9 +1,19 @@
-interface OpenCodeConfigDirOptions {
-  binary: 'opencode' | 'opencode-desktop';
-  version?: string | null;
-  checkExisting?: boolean;
+export type OpenCodeBinaryType = 'opencode' | 'opencode-desktop';
+export interface OpenCodeConfigDirOptions {
+    binary: OpenCodeBinaryType;
+    version?: string | null;
+    checkExisting?: boolean;
 }
-export declare function getOpenCodeConfigDir(
-  options: OpenCodeConfigDirOptions
-): string;
-export {};
+export interface OpenCodeConfigPaths {
+    configDir: string;
+    configJson: string;
+    configJsonc: string;
+    packageJson: string;
+    omoConfig: string;
+}
+export declare const TAURI_APP_IDENTIFIER = "ai.opencode.desktop";
+export declare const TAURI_APP_IDENTIFIER_DEV = "ai.opencode.desktop.dev";
+export declare function isDevBuild(version: string | null | undefined): boolean;
+export declare function getOpenCodeConfigDir(options: OpenCodeConfigDirOptions): string;
+export declare function getOpenCodeConfigPaths(options: OpenCodeConfigDirOptions): OpenCodeConfigPaths;
+export declare function detectExistingConfigDir(binary: OpenCodeBinaryType, version?: string | null): string | null;