codex-linux 1.0.0

package/src/main/config/SettingsManager.ts

@@ -0,0 +1,163 @@
+import { EventEmitter } from 'events';
+import log from 'electron-log';
+import * as fs from 'fs';
+import * as path from 'path';
+import { app } from 'electron';
+
+export interface WorktreeSettings {
+  worktreeLocation: string;
+  branchPrefix: string;
+  autoCleanup: boolean;
+  maxWorktrees: number;
+}
+
+export interface SessionSettings {
+  contextCompactionThreshold: number;
+  autoCompact: boolean;
+  compactOnClose: boolean;
+}
+
+export interface ClaudeCodeSettings {
+  worktree: WorktreeSettings;
+  session: SessionSettings;
+}
+
+const DEFAULT_SETTINGS: ClaudeCodeSettings = {
+  worktree: {
+    worktreeLocation: '.claude/worktrees',
+    branchPrefix: 'claude-',
+    autoCleanup: true,
+    maxWorktrees: 10,
+  },
+  session: {
+    contextCompactionThreshold: 0.8,
+    autoCompact: true,
+    compactOnClose: true,
+  },
+};
+
+export class SettingsManager extends EventEmitter {
+  private settings: ClaudeCodeSettings;
+  private settingsPath: string;
+
+  constructor(configDir?: string) {
+    super();
+    this.settingsPath = path.join(configDir || app.getPath('userData'), 'codex-settings.json');
+    this.settings = this.loadSettings();
+  }
+
+  private loadSettings(): ClaudeCodeSettings {
+    try {
+      if (fs.existsSync(this.settingsPath)) {
+        const data = fs.readFileSync(this.settingsPath, 'utf-8');
+        const parsed = JSON.parse(data) as Partial<ClaudeCodeSettings>;
+        
+        return {
+          worktree: { ...DEFAULT_SETTINGS.worktree, ...parsed.worktree },
+          session: { ...DEFAULT_SETTINGS.session, ...parsed.session },
+        };
+      }
+    } catch (error) {
+      log.error('Failed to load settings:', error);
+    }
+    
+    return { ...DEFAULT_SETTINGS };
+  }
+
+  private saveSettings(): void {
+    try {
+      const dir = path.dirname(this.settingsPath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      
+      fs.writeFileSync(this.settingsPath, JSON.stringify(this.settings, null, 2));
+      log.info('Settings saved');
+    } catch (error) {
+      log.error('Failed to save settings:', error);
+    }
+  }
+
+  getWorktreeSettings(): WorktreeSettings {
+    return { ...this.settings.worktree };
+  }
+
+  async setWorktreeLocation(location: string): Promise<void> {
+    this.settings.worktree.worktreeLocation = location;
+    this.saveSettings();
+    this.emit('settings:updated', this.settings);
+    log.info(`Worktree location set to: ${location}`);
+  }
+
+  async setBranchPrefix(prefix: string): Promise<void> {
+    this.settings.worktree.branchPrefix = prefix;
+    this.saveSettings();
+    this.emit('settings:updated', this.settings);
+    log.info(`Branch prefix set to: ${prefix}`);
+  }
+
+  async setWorktreeAutoCleanup(enabled: boolean): Promise<void> {
+    this.settings.worktree.autoCleanup = enabled;
+    this.saveSettings();
+    this.emit('settings:updated', this.settings);
+    log.info(`Worktree auto-cleanup: ${enabled}`);
+  }
+
+  async setMaxWorktrees(max: number): Promise<void> {
+    this.settings.worktree.maxWorktrees = max;
+    this.saveSettings();
+    this.emit('settings:updated', this.settings);
+    log.info(`Max worktrees set to: ${max}`);
+  }
+
+  getSessionSettings(): SessionSettings {
+    return { ...this.settings.session };
+  }
+
+  async setContextCompactionThreshold(threshold: number): Promise<void> {
+    this.settings.session.contextCompactionThreshold = Math.max(0, Math.min(1, threshold));
+    this.saveSettings();
+    this.emit('settings:updated', this.settings);
+    log.info(`Context compaction threshold set to: ${threshold}`);
+  }
+
+  async setAutoCompact(enabled: boolean): Promise<void> {
+    this.settings.session.autoCompact = enabled;
+    this.saveSettings();
+    this.emit('settings:updated', this.settings);
+    log.info(`Auto-compact: ${enabled}`);
+  }
+
+  async setCompactOnClose(enabled: boolean): Promise<void> {
+    this.settings.session.compactOnClose = enabled;
+    this.saveSettings();
+    this.emit('settings:updated', this.settings);
+    log.info(`Compact on close: ${enabled}`);
+  }
+
+  getAllSettings(): ClaudeCodeSettings {
+    return { ...this.settings };
+  }
+
+  async updateSettings(updates: Partial<ClaudeCodeSettings>): Promise<void> {
+    this.settings = {
+      worktree: { ...this.settings.worktree, ...updates.worktree },
+      session: { ...this.settings.session, ...updates.session },
+    };
+    this.saveSettings();
+    this.emit('settings:updated', this.settings);
+  }
+
+  async resetToDefaults(): Promise<void> {
+    this.settings = { ...DEFAULT_SETTINGS };
+    this.saveSettings();
+    this.emit('settings:reset');
+    log.info('Settings reset to defaults');
+  }
+
+  cleanup(): void {
+    this.removeAllListeners();
+  }
+}
+
+export default SettingsManager;

package/src/main/connectors/ConnectorManager.ts

@@ -0,0 +1,175 @@
+import { EventEmitter } from 'events';
+import log from 'electron-log';
+import fetch from 'node-fetch';
+import { ConnectorConfig, ConnectorCredentials } from '../../shared/types';
+
+export class ConnectorManager extends EventEmitter {
+  private connectors: Map<string, ConnectorConfig> = new Map();
+  private credentials: Map<string, ConnectorCredentials> = new Map();
+
+  constructor() {
+    super();
+  }
+
+  async registerConnector(config: ConnectorConfig): Promise<void> {
+    this.connectors.set(config.id, config);
+    this.emit('connector:registered', config);
+    log.info(`Registered connector: ${config.type} (${config.id})`);
+  }
+
+  async removeConnector(connectorId: string): Promise<void> {
+    this.connectors.delete(connectorId);
+    this.credentials.delete(connectorId);
+    this.emit('connector:removed', connectorId);
+  }
+
+  getConnector(connectorId: string): ConnectorConfig | undefined {
+    return this.connectors.get(connectorId);
+  }
+
+  getConnectorsByType(type: string): ConnectorConfig[] {
+    return Array.from(this.connectors.values()).filter(c => c.type === type);
+  }
+
+  async setCredentials(connectorId: string, creds: ConnectorCredentials): Promise<void> {
+    this.credentials.set(connectorId, creds);
+    log.info(`Credentials set for connector: ${connectorId}`);
+  }
+
+  private getCredentials(connectorId: string): ConnectorCredentials | undefined {
+    return this.credentials.get(connectorId);
+  }
+
+  // Jira Connector
+  async createJiraIssue(connectorId: string, issue: {
+    project: string;
+    summary: string;
+    description: string;
+    issueType?: string;
+  }): Promise<any> {
+    const creds = this.getCredentials(connectorId);
+    if (!creds?.accessToken) throw new Error('No credentials for Jira');
+
+    const connector = this.connectors.get(connectorId);
+    const baseUrl = connector?.config?.baseUrl || 'https://api.atlassian.com';
+
+    const response = await fetch(`${baseUrl}/rest/api/3/issue`, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${creds.accessToken}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        fields: {
+          project: { key: issue.project },
+          summary: issue.summary,
+          description: {
+            type: 'doc',
+            version: 1,
+            content: [{
+              type: 'paragraph',
+              content: [{ type: 'text', text: issue.description }],
+            }],
+          },
+          issuetype: { name: issue.issueType || 'Task' },
+        },
+      }),
+    });
+
+    if (!response.ok) throw new Error(`Jira API error: ${response.statusText}`);
+    return response.json();
+  }
+
+  // Notion Connector
+  async createNotionPage(connectorId: string, page: {
+    databaseId: string;
+    title: string;
+    content?: string;
+  }): Promise<any> {
+    const creds = this.getCredentials(connectorId);
+    if (!creds?.accessToken) throw new Error('No credentials for Notion');
+
+    const response = await fetch('https://api.notion.com/v1/pages', {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${creds.accessToken}`,
+        'Content-Type': 'application/json',
+        'Notion-Version': '2022-06-28',
+      },
+      body: JSON.stringify({
+        parent: { database_id: page.databaseId },
+        properties: {
+          Name: {
+            title: [{ text: { content: page.title } }],
+          },
+        },
+        children: page.content ? [{
+          object: 'block',
+          type: 'paragraph',
+          paragraph: {
+            rich_text: [{ text: { content: page.content } }],
+          },
+        }] : undefined,
+      }),
+    });
+
+    if (!response.ok) throw new Error(`Notion API error: ${response.statusText}`);
+    return response.json();
+  }
+
+  // Sentry Connector
+  async getSentryIssues(connectorId: string, project: string): Promise<any> {
+    const creds = this.getCredentials(connectorId);
+    if (!creds?.apiKey) throw new Error('No API key for Sentry');
+
+    const connector = this.connectors.get(connectorId);
+    const org = connector?.config?.organization || '';
+
+    const response = await fetch(`https://sentry.io/api/0/projects/${org}/${project}/issues/`, {
+      headers: {
+        'Authorization': `Bearer ${creds.apiKey}`,
+      },
+    });
+
+    if (!response.ok) throw new Error(`Sentry API error: ${response.statusText}`);
+    return response.json();
+  }
+
+  async createSentryIssue(connectorId: string, issue: {
+    project: string;
+    title: string;
+    message: string;
+    level?: 'error' | 'warning' | 'info';
+  }): Promise<any> {
+    const creds = this.getCredentials(connectorId);
+    if (!creds?.apiKey) throw new Error('No API key for Sentry');
+
+    const connector = this.connectors.get(connectorId);
+    const org = connector?.config?.organization || '';
+
+    const response = await fetch(`https://sentry.io/api/0/projects/${org}/${issue.project}/events/`, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${creds.apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        event_id: Math.random().toString(36).substring(2),
+        title: issue.title,
+        message: issue.message,
+        level: issue.level || 'error',
+      }),
+    });
+
+    if (!response.ok) throw new Error(`Sentry API error: ${response.statusText}`);
+    return response.json();
+  }
+
+  cleanup(): void {
+    this.connectors.clear();
+    this.credentials.clear();
+    this.removeAllListeners();
+  }
+}
+
+export default ConnectorManager;

package/src/main/connectors/DatabaseConnector.ts

@@ -0,0 +1,212 @@
+import { EventEmitter } from 'events';
+import log from 'electron-log';
+
+export interface DatabaseConfig {
+  type: 'postgresql' | 'mysql' | 'mongodb' | 'sqlite';
+  host?: string;
+  port?: number;
+  database: string;
+  username?: string;
+  password?: string;
+  filename?: string;
+  connectionString?: string;
+}
+
+export interface QueryResult {
+  rows: any[];
+  rowCount: number;
+  fields?: Array<{ name: string; type: string }>;
+}
+
+export class DatabaseConnector extends EventEmitter {
+  private config: DatabaseConfig | null = null;
+  private client: any = null;
+  private connected = false;
+
+  constructor() {
+    super();
+  }
+
+  async connect(config: DatabaseConfig): Promise<void> {
+    this.config = config;
+
+    try {
+      switch (config.type) {
+        case 'postgresql':
+          await this.connectPostgres(config);
+          break;
+        case 'mysql':
+          await this.connectMysql(config);
+          break;
+        case 'mongodb':
+          await this.connectMongodb(config);
+          break;
+        case 'sqlite':
+          await this.connectSqlite(config);
+          break;
+        default:
+          throw new Error(`Unsupported database type: ${config.type}`);
+      }
+
+      this.connected = true;
+      log.info(`Connected to ${config.type} database`);
+      this.emit('connected');
+    } catch (error) {
+      log.error('Database connection failed:', error);
+      throw error;
+    }
+  }
+
+  private async connectPostgres(config: DatabaseConfig): Promise<void> {
+    const { Client } = await import('pg');
+    this.client = new Client({
+      host: config.host || 'localhost',
+      port: config.port || 5432,
+      database: config.database,
+      user: config.username,
+      password: config.password,
+      connectionString: config.connectionString,
+    });
+    await this.client.connect();
+  }
+
+  private async connectMysql(config: DatabaseConfig): Promise<void> {
+    const mysql = await import('mysql2/promise');
+    this.client = await mysql.createPool({
+      host: config.host || 'localhost',
+      port: config.port || 3306,
+      database: config.database,
+      user: config.username,
+      password: config.password,
+      waitForConnections: true,
+      connectionLimit: 10,
+    });
+  }
+
+  private async connectMongodb(config: DatabaseConfig): Promise<void> {
+    const { MongoClient } = await import('mongodb');
+    const url = config.connectionString || 
+      `mongodb://${config.username}:${config.password}@${config.host || 'localhost'}:${config.port || 27017}/${config.database}`;
+    this.client = new MongoClient(url);
+    await this.client.connect();
+  }
+
+  private async connectSqlite(config: DatabaseConfig): Promise<void> {
+    const Database = (await import('better-sqlite3')).default;
+    this.client = new Database(config.filename || config.database);
+  }
+
+  async disconnect(): Promise<void> {
+    if (!this.client) return;
+
+    try {
+      if (this.config?.type === 'postgresql') {
+        await this.client.end();
+      } else if (this.config?.type === 'mongodb') {
+        await this.client.close();
+      } else if (this.config?.type === 'mysql') {
+        await this.client.end();
+      } else if (this.config?.type === 'sqlite') {
+        this.client.close();
+      }
+    } catch (error) {
+      log.error('Disconnect error:', error);
+    }
+
+    this.connected = false;
+    this.client = null;
+    this.emit('disconnected');
+  }
+
+  async query(sql: string, params?: any[]): Promise<QueryResult> {
+    if (!this.connected || !this.client) {
+      throw new Error('Not connected to database');
+    }
+
+    try {
+      switch (this.config?.type) {
+        case 'postgresql':
+          return await this.queryPostgres(sql, params);
+        case 'mysql':
+          return await this.queryMysql(sql, params);
+        case 'mongodb':
+          return await this.queryMongodb(sql, params);
+        case 'sqlite':
+          return await this.querySqlite(sql, params);
+        default:
+          throw new Error('Unknown database type');
+      }
+    } catch (error) {
+      log.error('Query error:', error);
+      throw error;
+    }
+  }
+
+  private async queryPostgres(sql: string, params?: any[]): Promise<QueryResult> {
+    const result = await this.client.query(sql, params);
+    return {
+      rows: result.rows,
+      rowCount: result.rowCount,
+      fields: result.fields?.map((f: any) => ({ name: f.name, type: f.dataTypeID })),
+    };
+  }
+
+  private async queryMysql(sql: string, params?: any[]): Promise<QueryResult> {
+    const [rows, fields] = await this.client.execute(sql, params);
+    return {
+      rows: Array.isArray(rows) ? rows : [],
+      rowCount: Array.isArray(rows) ? rows.length : 0,
+      fields: fields?.map((f: any) => ({ name: f.name, type: f.type })),
+    };
+  }
+
+  private async queryMongodb(sql: string, params?: any[]): Promise<QueryResult> {
+    // MongoDB uses a simple SQL-like syntax for this wrapper
+    const [collection, operation] = sql.split('.');
+    const collectionObj = this.client.db().collection(collection);
+
+    if (operation?.trim() === 'find') {
+      const docs = await collectionObj.find(params?.[0] || {}).toArray();
+      return { rows: docs, rowCount: docs.length };
+    } else if (operation?.trim() === 'insert') {
+      const result = await collectionObj.insertOne(params?.[0] || {});
+      return { rows: [result], rowCount: 1 };
+    } else if (operation?.trim() === 'update') {
+      const result = await collectionObj.updateOne(params?.[0], params?.[1]);
+      return { rows: [result], rowCount: result.modifiedCount };
+    } else if (operation?.trim() === 'delete') {
+      const result = await collectionObj.deleteOne(params?.[0]);
+      return { rows: [result], rowCount: result.deletedCount };
+    }
+
+    return { rows: [], rowCount: 0 };
+  }
+
+  private async querySqlite(sql: string, params?: any[]): Promise<QueryResult> {
+    const stmt = this.client.prepare(sql);
+    const isSelect = sql.trim().toLowerCase().startsWith('select');
+
+    if (isSelect) {
+      const rows = stmt.all(...(params || []));
+      return { rows, rowCount: rows.length };
+    } else {
+      const info = stmt.run(...(params || []));
+      return { rows: [], rowCount: info.changes };
+    }
+  }
+
+  isConnected(): boolean {
+    return this.connected;
+  }
+
+  getConfig(): DatabaseConfig | null {
+    return this.config ? { ...this.config, password: '***' } : null;
+  }
+
+  cleanup(): void {
+    this.disconnect();
+    this.removeAllListeners();
+  }
+}
+
+export default DatabaseConnector;