@openharmonyinsight/opencode-oh 0.1.0

package/src/tui/index.ts

@@ -0,0 +1,159 @@
+import inquirer from 'inquirer';
+import type { ProviderInput } from '../config/types.js';
+import { getAllProviderTemplates } from '../provider/templates.js';
+import { validateApiKey } from '../validation/index.js';
+import type { ValidationResult } from '../validation/index.js';
+
+type Language = 'en' | 'zh';
+
+const MESSAGES: Record<Language, Record<string, string>> = {
+  en: {
+    welcome: 'Welcome to opencode-oh - OpenCode Helper Tool',
+    selectProvider: 'Select a provider to configure:',
+    providerBaseURL: 'Provider Base URL:',
+    enterApiKey: 'Enter API key:',
+    enterModelName: 'Enter model name:',
+    validating: 'Validating API key...',
+    validationSuccess: 'API key validated successfully',
+    validationFailed: 'API key validation failed',
+    retry: 'Would you like to retry?',
+    skipValidation: 'Skip validation and proceed?',
+    configUpdated: 'Configuration updated successfully',
+    backupCreated: 'Backup created at:',
+    errorOccurred: 'An error occurred:',
+    noProviders: 'No providers available'
+  },
+  zh: {
+    welcome: '欢迎使用 opencode-oh - OpenCode 辅助工具',
+    selectProvider: '选择要配置的提供商:',
+    providerBaseURL: '提供商 Base URL:',
+    enterApiKey: '输入 API key:',
+    enterModelName: '输入模型名称:',
+    validating: '正在验证 API key...',
+    validationSuccess: 'API key 验证成功',
+    validationFailed: 'API key 验证失败',
+    retry: '是否重试?',
+    skipValidation: '跳过验证并继续?',
+    configUpdated: '配置更新成功',
+    backupCreated: '备份已创建于:',
+    errorOccurred: '发生错误:',
+    noProviders: '没有可用的提供商'
+  }
+};
+
+export class TUIManager {
+  private language: Language;
+  private messages: Record<string, string>;
+
+  constructor() {
+    const locale = process.env.LANG || 'en_US';
+    this.language = locale.startsWith('zh') ? 'zh' : 'en';
+    this.messages = MESSAGES[this.language];
+  }
+
+  async run(): Promise<ProviderInput | null> {
+    console.log(`\n${this.messages.welcome}\n`);
+
+    const providers = getAllProviderTemplates();
+    if (providers.length === 0) {
+      console.error(this.messages.noProviders);
+      return null;
+    }
+
+    const { providerId } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'providerId',
+        message: this.messages.selectProvider,
+        choices: providers.map(p => ({
+          name: p.displayName,
+          value: p.id
+        }))
+      }
+    ]);
+
+    const selectedProvider = providers.find(p => p.id === providerId);
+    if (selectedProvider) {
+      console.log(`\n${this.messages.providerBaseURL} ${selectedProvider.baseURL}\n`);
+    }
+
+    const { apiKey } = await inquirer.prompt([
+      {
+        type: 'password',
+        name: 'apiKey',
+        message: this.messages.enterApiKey,
+        validate: (input: string) => input.length > 0 || 'API key is required'
+      }
+    ]);
+
+    const { modelName } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'modelName',
+        message: this.messages.enterModelName,
+        validate: (input: string) => input.length > 0 || 'Model name is required'
+      }
+    ]);
+
+    const input: ProviderInput = { providerId, apiKey, modelName };
+    
+    return await this.validateWithRetry(input);
+  }
+
+  private async validateWithRetry(input: ProviderInput): Promise<ProviderInput | null> {
+    console.log(`\n${this.messages.validating}`);
+    
+    const result: ValidationResult = await validateApiKey(input.providerId, input.apiKey, input.modelName);
+
+    if (result.valid) {
+      console.log(`✓ ${this.messages.validationSuccess}\n`);
+      return input;
+    }
+
+    console.log(`✗ ${this.messages.validationFailed}`);
+    if (result.error) {
+      console.log(`  ${result.error}`);
+    }
+
+    const { action } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'action',
+        message: this.messages.retry,
+        choices: [
+          { name: 'Retry', value: 'retry' },
+          { name: 'Skip', value: 'skip' },
+          { name: 'Cancel', value: 'cancel' }
+        ]
+      }
+    ]);
+
+    if (action === 'retry') {
+      const { apiKey } = await inquirer.prompt([
+        {
+          type: 'password',
+          name: 'apiKey',
+          message: this.messages.enterApiKey
+        }
+      ]);
+      input.apiKey = apiKey;
+      return this.validateWithRetry(input);
+    } else if (action === 'skip') {
+      return input;
+    }
+
+    return null;
+  }
+
+  showMessage(key: string): void {
+    console.log(this.messages[key]);
+  }
+
+  showError(message: string): void {
+    console.error(`${this.messages.errorOccurred} ${message}`);
+  }
+
+  showBackup(path: string): void {
+    console.log(`${this.messages.backupCreated} ${path}`);
+  }
+}

package/src/validation/index.ts

@@ -0,0 +1,30 @@
+import { getProviderTemplate } from '../provider/templates.js';
+
+export interface ValidationResult {
+  valid: boolean;
+  error?: string;
+}
+
+export async function validateApiKey(providerId: string, apiKey: string, model?: string): Promise<ValidationResult> {
+  const template = getProviderTemplate(providerId);
+  if (!template) {
+    return { valid: false, error: `Unknown provider: ${providerId}` };
+  }
+
+  if (!template.supportsApiKeyValidation || !template.validateApiKey) {
+    return { valid: true };
+  }
+
+  try {
+    const valid = await template.validateApiKey(apiKey, model || '');
+    if (!valid) {
+      return { valid: false, error: 'API key validation failed' };
+    }
+    return { valid: true };
+  } catch (error) {
+    return { 
+      valid: false, 
+      error: `Validation error: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}

package/tests/config.test.ts

@@ -0,0 +1,117 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { ConfigManager } from '../src/config/index.js';
+import type { ProviderInput } from '../src/config/types.js';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+describe('ConfigManager', () => {
+  let configManager: ConfigManager;
+  let testConfigPath: string;
+  let testConfigDir: string;
+
+  beforeEach(() => {
+    testConfigDir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencode-oh-test-'));
+    testConfigPath = path.join(testConfigDir, 'opencode.json');
+    configManager = new ConfigManager();
+    (configManager as any).configPath = testConfigPath;
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(testConfigDir)) {
+      fs.rmSync(testConfigDir, { recursive: true, force: true });
+    }
+  });
+
+  it('should return null when config does not exist', () => {
+    const config = configManager.readConfig();
+    expect(config).toBeNull();
+  });
+
+  it('should read existing config', () => {
+    const testConfig = {
+      $schema: 'https://opencode.ai/config.json',
+      provider: {}
+    };
+    fs.writeFileSync(testConfigPath, JSON.stringify(testConfig));
+    const config = configManager.readConfig();
+    expect(config).toEqual(testConfig);
+  });
+
+  it('should write config', () => {
+    const testConfig = {
+      $schema: 'https://opencode.ai/config.json',
+      provider: {}
+    };
+    configManager.writeConfig(testConfig);
+    expect(fs.existsSync(testConfigPath)).toBe(true);
+    const read = JSON.parse(fs.readFileSync(testConfigPath, 'utf-8'));
+    expect(read).toEqual(testConfig);
+  });
+
+  it('should backup existing config', () => {
+    const testConfig = {
+      $schema: 'https://opencode.ai/config.json',
+      provider: {}
+    };
+    fs.writeFileSync(testConfigPath, JSON.stringify(testConfig));
+    const backupPath = configManager.backupConfig();
+    expect(backupPath).toBeTruthy();
+    expect(fs.existsSync(backupPath as string)).toBe(true);
+  });
+
+  it('should return null when backing up non-existent config', () => {
+    const backupPath = configManager.backupConfig();
+    expect(backupPath).toBeNull();
+  });
+
+  it('should add provider to config', () => {
+    const input: ProviderInput = {
+      providerId: 'volcengine',
+      apiKey: 'test-key',
+      modelName: 'test-model'
+    };
+    configManager.addProvider(input);
+    const config = configManager.readConfig();
+    expect(config).not.toBeNull();
+    expect(config?.provider.volcengine).toBeDefined();
+    expect(config?.provider.volcengine.options.apiKey).toBe('test-key');
+  });
+
+  it('should add provider to config when provider property is missing', () => {
+    const testConfig = {
+      $schema: 'https://opencode.ai/config.json'
+    };
+    fs.writeFileSync(testConfigPath, JSON.stringify(testConfig));
+
+    const input: ProviderInput = {
+      providerId: 'volcengine',
+      apiKey: 'test-key',
+      modelName: 'test-model'
+    };
+    configManager.addProvider(input);
+    const config = configManager.readConfig();
+    expect(config).not.toBeNull();
+    expect(config?.provider.volcengine).toBeDefined();
+    expect(config?.provider.volcengine.options.apiKey).toBe('test-key');
+  });
+
+  it('should add provider to config when provider is null', () => {
+    const testConfig = {
+      $schema: 'https://opencode.ai/config.json',
+      provider: null
+    };
+    fs.writeFileSync(testConfigPath, JSON.stringify(testConfig));
+
+    const input: ProviderInput = {
+      providerId: 'volcengine',
+      apiKey: 'test-key',
+      modelName: 'test-model'
+    };
+    configManager.addProvider(input);
+    const config = configManager.readConfig();
+    expect(config).not.toBeNull();
+    expect(config?.provider.volcengine).toBeDefined();
+    expect(config?.provider.volcengine.options.apiKey).toBe('test-key');
+  });
+});

package/tests/validation.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { validateApiKey } from '../src/validation/index.js';
+
+describe('validateApiKey', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should validate volcengine API key successfully', async () => {
+    const mockFetch = vi.fn().mockResolvedValue({
+      ok: true
+    });
+    global.fetch = mockFetch;
+
+    const result = await validateApiKey('volcengine', 'valid-key');
+    expect(result.valid).toBe(true);
+  });
+
+  it('should return error for invalid volcengine API key', async () => {
+    const mockFetch = vi.fn().mockResolvedValue({
+      ok: false
+    });
+    global.fetch = mockFetch;
+
+    const result = await validateApiKey('volcengine', 'invalid-key');
+    expect(result.valid).toBe(false);
+    expect(result.error).toBeDefined();
+  });
+
+  it('should handle network errors', async () => {
+    const mockFetch = vi.fn().mockRejectedValue(new Error('Network error'));
+    global.fetch = mockFetch;
+
+    const result = await validateApiKey('volcengine', 'test-key');
+    expect(result.valid).toBe(false);
+    expect(result.error).toBe('API key validation failed');
+  });
+
+  it('should return error for unknown provider', async () => {
+    const result = await validateApiKey('unknown', 'test-key');
+    expect(result.valid).toBe(false);
+    expect(result.error).toContain('Unknown provider');
+  });
+});

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "outDir": "./dist",
+    "rootDir": ".",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "types": ["node", "vitest/globals"]
+  },
+  "include": ["src/**/*", "tests/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/vitest.config.ts

@@ -0,0 +1,19 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+      exclude: [
+        'node_modules/',
+        'dist/',
+        'tests/',
+        '**/*.test.ts',
+        '**/*.config.ts'
+      ]
+    }
+  }
+});