codex-linux 1.0.0

package/src/main/realtime/RealtimeManager.ts

@@ -0,0 +1,147 @@
+import { EventEmitter } from 'events';
+import log from 'electron-log';
+import { RealtimeConfig } from '../../shared/types';
+
+export interface SpeechRecognitionResult {
+  transcript: string;
+  confidence: number;
+  isFinal: boolean;
+  timestamp: Date;
+}
+
+export interface SpeechSynthesisOptions {
+  text: string;
+  voice?: string;
+  rate?: number;
+  pitch?: number;
+  volume?: number;
+}
+
+export class RealtimeManager extends EventEmitter {
+  private config: RealtimeConfig;
+  private isListening = false;
+  private isSpeaking = false;
+
+  constructor() {
+    super();
+    this.config = {
+      provider: 'openai',
+      enableSTT: false,
+      enableTTS: false,
+      language: 'en-US',
+      model: 'gpt-4o-audio-preview',
+      voice: 'alloy',
+    };
+  }
+
+  async initialize(config?: Partial<RealtimeConfig>): Promise<void> {
+    if (config) {
+      this.config = { ...this.config, ...config };
+    }
+
+    log.info('RealtimeManager initialized', { 
+      provider: this.config.provider,
+      stt: this.config.enableSTT,
+      tts: this.config.enableTTS 
+    });
+  }
+
+  configure(config: Partial<RealtimeConfig>): void {
+    this.config = { ...this.config, ...config };
+    log.info('Realtime configuration updated');
+  }
+
+  getConfig(): RealtimeConfig {
+    return { ...this.config };
+  }
+
+  // Speech-to-Text - handled by renderer via IPC
+  async startListening(): Promise<void> {
+    if (this.isListening) return;
+    this.isListening = true;
+    this.emit('listening:started');
+    log.info('Speech recognition started (renderer handling)');
+  }
+
+  stopListening(): void {
+    if (!this.isListening) return;
+    this.isListening = false;
+    this.emit('listening:stopped');
+    log.info('Speech recognition stopped');
+  }
+
+  isActive(): boolean {
+    return this.isListening;
+  }
+
+  // Speech recognition results from renderer
+  handleSpeechResult(result: SpeechRecognitionResult): void {
+    this.emit('speech:result', result);
+  }
+
+  handleSpeechError(error: { error: string }): void {
+    this.emit('speech:error', error);
+  }
+
+  // Text-to-Speech - handled by renderer via IPC
+  async speak(options: SpeechSynthesisOptions): Promise<void> {
+    if (this.isSpeaking) {
+      this.stopSpeaking();
+    }
+    
+    this.isSpeaking = true;
+    this.emit('speech:start');
+    this.emit('speak:request', options);
+    log.debug('TTS requested:', options.text.substring(0, 50) + '...');
+  }
+
+  onSpeechEnd(): void {
+    this.isSpeaking = false;
+    this.emit('speech:end');
+  }
+
+  onSpeechError(error: Error): void {
+    this.isSpeaking = false;
+    this.emit('speech:error', { error: error.message });
+  }
+
+  stopSpeaking(): void {
+    if (!this.isSpeaking) return;
+    this.isSpeaking = false;
+    this.emit('speech:stop');
+    this.emit('speech:stopped');
+  }
+
+  isSpeakingActive(): boolean {
+    return this.isSpeaking;
+  }
+
+  // Available voices
+  prepareRealtimeConnection(options: {
+    apiKey: string;
+    model?: string;
+    voice?: string;
+  }): { ready: boolean; message: string } {
+    log.info('Preparing OpenAI Realtime connection...');
+    
+    this.emit('realtime:ready', {
+      model: options.model || this.config.model,
+      voice: options.voice || this.config.voice,
+      provider: this.config.provider,
+    });
+
+    return { 
+      ready: true, 
+      message: 'Realtime API connection prepared. Use frontend SDK for actual connection.' 
+    };
+  }
+
+  cleanup(): void {
+    this.stopListening();
+    this.stopSpeaking();
+    this.removeAllListeners();
+    log.info('RealtimeManager cleaned up');
+  }
+}
+
+export default RealtimeManager;

package/src/main/remote/CloudEnvironmentManager.ts

@@ -0,0 +1,253 @@
+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 CloudEnvironmentConfig {
+  id: string;
+  name: string;
+  description?: string;
+  networkAccess: 'full' | 'no-internet' | 'custom';
+  allowedDomains?: string[];
+  blockedDomains?: string[];
+  environmentVariables?: Record<string, string>;
+  preinstalledTools?: string[];
+  isDefault?: boolean;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface CloudEnvironmentCreateOptions {
+  name: string;
+  description?: string;
+  networkAccess?: 'full' | 'no-internet' | 'custom';
+  allowedDomains?: string[];
+  blockedDomains?: string[];
+  environmentVariables?: Record<string, string>;
+  preinstalledTools?: string[];
+  isDefault?: boolean;
+}
+
+const DEFAULT_ENVIRONMENTS: CloudEnvironmentConfig[] = [
+  {
+    id: 'default-full',
+    name: 'Full Internet',
+    description: 'Full internet access for remote sessions',
+    networkAccess: 'full',
+    isDefault: true,
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  },
+  {
+    id: 'default-offline',
+    name: 'No Internet',
+    description: 'Isolated environment without internet access',
+    networkAccess: 'no-internet',
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  },
+];
+
+export class CloudEnvironmentManager extends EventEmitter {
+  private environments: Map<string, CloudEnvironmentConfig> = new Map();
+  private configPath: string;
+
+  constructor(configDir?: string) {
+    super();
+    this.configPath = path.join(configDir || app.getPath('userData'), 'cloud-environments.json');
+    this.loadEnvironments();
+  }
+
+  private loadEnvironments(): void {
+    try {
+      if (fs.existsSync(this.configPath)) {
+        const data = fs.readFileSync(this.configPath, 'utf-8');
+        const parsed = JSON.parse(data) as CloudEnvironmentConfig[];
+        
+        for (const env of parsed) {
+          this.environments.set(env.id, env);
+        }
+        
+        log.info(`Loaded ${this.environments.size} cloud environments`);
+      } else {
+        for (const env of DEFAULT_ENVIRONMENTS) {
+          this.environments.set(env.id, env);
+        }
+        this.saveEnvironments();
+      }
+    } catch (error) {
+      log.error('Failed to load cloud environments:', error);
+      for (const env of DEFAULT_ENVIRONMENTS) {
+        this.environments.set(env.id, env);
+      }
+    }
+  }
+
+  private saveEnvironments(): void {
+    try {
+      const dir = path.dirname(this.configPath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      
+      const environments = Array.from(this.environments.values());
+      fs.writeFileSync(this.configPath, JSON.stringify(environments, null, 2));
+      log.info('Saved cloud environments');
+    } catch (error) {
+      log.error('Failed to save cloud environments:', error);
+    }
+  }
+
+  async createEnvironment(options: CloudEnvironmentCreateOptions): Promise<CloudEnvironmentConfig> {
+    const id = `env-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    
+    const environment: CloudEnvironmentConfig = {
+      id,
+      name: options.name,
+      description: options.description,
+      networkAccess: options.networkAccess || 'full',
+      allowedDomains: options.allowedDomains,
+      blockedDomains: options.blockedDomains,
+      environmentVariables: options.environmentVariables,
+      preinstalledTools: options.preinstalledTools,
+      isDefault: options.isDefault,
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    };
+
+    if (options.isDefault) {
+      for (const [envId, env] of this.environments) {
+        if (env.isDefault) {
+          env.isDefault = false;
+          this.environments.set(envId, env);
+        }
+      }
+    }
+
+    this.environments.set(id, environment);
+    this.saveEnvironments();
+    
+    this.emit('environment:created', environment);
+    log.info(`Created cloud environment: ${id}`);
+    
+    return environment;
+  }
+
+  async updateEnvironment(
+    id: string,
+    updates: Partial<CloudEnvironmentCreateOptions>
+  ): Promise<CloudEnvironmentConfig> {
+    const environment = this.environments.get(id);
+    if (!environment) {
+      throw new Error(`Environment ${id} not found`);
+    }
+
+    if (updates.isDefault) {
+      for (const [envId, env] of this.environments) {
+        if (env.isDefault && envId !== id) {
+          env.isDefault = false;
+          this.environments.set(envId, env);
+        }
+      }
+    }
+
+    const updated: CloudEnvironmentConfig = {
+      ...environment,
+      ...updates,
+      updatedAt: new Date().toISOString(),
+    };
+
+    this.environments.set(id, updated);
+    this.saveEnvironments();
+    
+    this.emit('environment:updated', updated);
+    log.info(`Updated cloud environment: ${id}`);
+    
+    return updated;
+  }
+
+  async deleteEnvironment(id: string): Promise<void> {
+    const environment = this.environments.get(id);
+    if (!environment) {
+      throw new Error(`Environment ${id} not found`);
+    }
+
+    if (environment.isDefault) {
+      throw new Error('Cannot delete the default environment');
+    }
+
+    this.environments.delete(id);
+    this.saveEnvironments();
+    
+    this.emit('environment:deleted', id);
+    log.info(`Deleted cloud environment: ${id}`);
+  }
+
+  getEnvironment(id: string): CloudEnvironmentConfig | undefined {
+    return this.environments.get(id);
+  }
+
+  getAllEnvironments(): CloudEnvironmentConfig[] {
+    return Array.from(this.environments.values());
+  }
+
+  getDefaultEnvironment(): CloudEnvironmentConfig | undefined {
+    for (const env of this.environments.values()) {
+      if (env.isDefault) {
+        return env;
+      }
+    }
+    return this.environments.values().next().value;
+  }
+
+  async setDefaultEnvironment(id: string): Promise<void> {
+    const environment = this.environments.get(id);
+    if (!environment) {
+      throw new Error(`Environment ${id} not found`);
+    }
+
+    for (const [envId, env] of this.environments) {
+      env.isDefault = envId === id;
+      this.environments.set(envId, env);
+    }
+
+    this.saveEnvironments();
+    this.emit('environment:default-changed', id);
+    log.info(`Set default environment to: ${id}`);
+  }
+
+  validateEnvironment(environment: CloudEnvironmentConfig): { valid: boolean; errors: string[] } {
+    const errors: string[] = [];
+
+    if (!environment.name || environment.name.trim().length === 0) {
+      errors.push('Environment name is required');
+    }
+
+    if (environment.networkAccess === 'custom') {
+      if (!environment.allowedDomains || environment.allowedDomains.length === 0) {
+        errors.push('Custom network access requires at least one allowed domain');
+      }
+    }
+
+    if (environment.environmentVariables) {
+      for (const [key, value] of Object.entries(environment.environmentVariables)) {
+        if (key.startsWith('ANTHROPIC_') || key.startsWith('CLAUDE_')) {
+          errors.push(`Cannot override reserved environment variable: ${key}`);
+        }
+      }
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+    };
+  }
+
+  cleanup(): void {
+    this.environments.clear();
+    this.removeAllListeners();
+  }
+}
+
+export default CloudEnvironmentManager;

package/src/main/remote/RemoteSessionManager.ts

@@ -0,0 +1,323 @@
+import { EventEmitter } from 'events';
+import log from 'electron-log';
+import fetch from 'node-fetch';
+
+export interface RemoteSessionConfig {
+  id: string;
+  name: string;
+  provider: 'anthropic';
+  model: string;
+  status: 'creating' | 'running' | 'stopped' | 'error';
+  createdAt: Date;
+  lastActivity: Date;
+  environment?: {
+    networkAccess?: 'full' | 'no-internet' | 'custom';
+    variables?: Record<string, string>;
+    preinstalledTools?: string[];
+  };
+  repositories?: {
+    owner: string;
+    repo: string;
+    branch?: string;
+  }[];
+}
+
+export interface RemoteSessionCreateOptions {
+  name?: string;
+  model?: string;
+  environment?: RemoteSessionConfig['environment'];
+  repositories?: RemoteSessionConfig['repositories'];
+}
+
+export class RemoteSessionManager extends EventEmitter {
+  private sessions: Map<string, RemoteSessionConfig> = new Map();
+  private apiKey: string;
+  private baseUrl: string;
+  private pollIntervals: Map<string, NodeJS.Timeout> = new Map();
+
+  constructor(apiKey: string) {
+    super();
+    this.apiKey = apiKey;
+    this.baseUrl = process.env.REMOTE_SESSION_URL || 'https://api.anthropic.com/v1';
+  }
+
+  async createSession(options: RemoteSessionCreateOptions = {}): Promise<RemoteSessionConfig> {
+    const sessionId = `session-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    
+    const session: RemoteSessionConfig = {
+      id: sessionId,
+      name: options.name || `Remote Session ${sessionId.slice(-4)}`,
+      provider: 'anthropic',
+      model: options.model || 'sonnet-4-20250514',
+      status: 'creating',
+      createdAt: new Date(),
+      lastActivity: new Date(),
+      environment: options.environment,
+      repositories: options.repositories
+    };
+
+    this.sessions.set(sessionId, session);
+    this.emit('session:creating', session);
+
+    try {
+      const response = await fetch(`${this.baseUrl}/remote_sessions`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': this.apiKey,
+          'anthropic-version': '2023-06-01'
+        },
+        body: JSON.stringify({
+          model: session.model,
+          environment: session.environment,
+          repositories: session.repositories
+        })
+      });
+
+      if (!response.ok) {
+        throw new Error(`Failed to create remote session: ${response.status}`);
+      }
+
+      const data = await response.json() as { session_id: string };
+      session.id = data.session_id;
+      session.status = 'running';
+
+      log.info(`Remote session created: ${session.id}`);
+      this.emit('session:created', session);
+      
+      this.startPolling(session.id);
+      
+      return session;
+    } catch (error) {
+      session.status = 'error';
+      log.error(`Failed to create remote session:`, error);
+      this.emit('session:error', { session, error });
+      throw error;
+    }
+  }
+
+  async getSession(sessionId: string): Promise<RemoteSessionConfig | undefined> {
+    return this.sessions.get(sessionId);
+  }
+
+  async listSessions(): Promise<RemoteSessionConfig[]> {
+    return Array.from(this.sessions.values());
+  }
+
+  async addRepository(
+    sessionId: string,
+    repo: { owner: string; repo: string; branch?: string }
+  ): Promise<void> {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+
+    if (!session.repositories) {
+      session.repositories = [];
+    }
+
+    const existingIndex = session.repositories.findIndex(
+      r => r.owner === repo.owner && r.repo === repo.repo
+    );
+
+    if (existingIndex >= 0) {
+      session.repositories[existingIndex] = repo;
+    } else {
+      session.repositories.push(repo);
+    }
+
+    try {
+      await fetch(`${this.baseUrl}/remote_sessions/${sessionId}/repositories`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': this.apiKey,
+          'anthropic-version': '2023-06-01'
+        },
+        body: JSON.stringify({ repositories: session.repositories })
+      });
+
+      this.emit('session:repository-added', { sessionId, repo });
+      log.info(`Added repository ${repo.owner}/${repo.repo} to session ${sessionId}`);
+    } catch (error) {
+      log.error(`Failed to add repository to session ${sessionId}:`, error);
+      throw error;
+    }
+  }
+
+  async removeRepository(sessionId: string, repoPath: string): Promise<void> {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+
+    const [owner, repo] = repoPath.split('/');
+    session.repositories = session.repositories?.filter(
+      r => !(r.owner === owner && r.repo === repo)
+    ) || [];
+
+    try {
+      await fetch(`${this.baseUrl}/remote_sessions/${sessionId}/repositories`, {
+        method: 'PUT',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': this.apiKey,
+          'anthropic-version': '2023-06-01'
+        },
+        body: JSON.stringify({ repositories: session.repositories })
+      });
+
+      this.emit('session:repository-removed', { sessionId, repoPath });
+      log.info(`Removed repository ${repoPath} from session ${sessionId}`);
+    } catch (error) {
+      log.error(`Failed to remove repository from session ${sessionId}:`, error);
+      throw error;
+    }
+  }
+
+  async getRepositories(sessionId: string): Promise<RemoteSessionConfig['repositories']> {
+    const session = this.sessions.get(sessionId);
+    return session?.repositories || [];
+  }
+
+  async deleteSession(sessionId: string): Promise<void> {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+
+    try {
+      await fetch(`${this.baseUrl}/remote_sessions/${sessionId}`, {
+        method: 'DELETE',
+        headers: {
+          'x-api-key': this.apiKey,
+          'anthropic-version': '2023-06-01'
+        }
+      });
+    } catch (error) {
+      log.warn(`Failed to delete remote session ${sessionId}:`, error);
+    }
+
+    this.stopPolling(sessionId);
+    this.sessions.delete(sessionId);
+    
+    this.emit('session:deleted', sessionId);
+    log.info(`Remote session deleted: ${sessionId}`);
+  }
+
+  async sendMessage(sessionId: string, message: string): Promise<string> {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+
+    if (session.status !== 'running') {
+      throw new Error(`Session ${sessionId} is not running`);
+    }
+
+    const response = await fetch(`${this.baseUrl}/remote_sessions/${sessionId}/messages`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': this.apiKey,
+        'anthropic-version': '2023-06-01'
+      },
+      body: JSON.stringify({
+        messages: [{ role: 'user', content: message }]
+      })
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to send message: ${response.status}`);
+    }
+
+    const data = await response.json() as { content: string };
+    session.lastActivity = new Date();
+    
+    return data.content;
+  }
+
+  async executeCommand(sessionId: string, command: string): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+
+    const response = await fetch(`${this.baseUrl}/remote_sessions/${sessionId}/execute`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': this.apiKey,
+        'anthropic-version': '2023-06-01'
+      },
+      body: JSON.stringify({
+        command
+      })
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to execute command: ${response.status}`);
+    }
+
+    const data = await response.json() as { stdout: string; stderr: string; exit_code: number };
+    session.lastActivity = new Date();
+
+    return {
+      stdout: data.stdout,
+      stderr: data.stderr,
+      exitCode: data.exit_code
+    };
+  }
+
+  private startPolling(sessionId: string): void {
+    const interval = setInterval(async () => {
+      try {
+        const response = await fetch(`${this.baseUrl}/remote_sessions/${sessionId}/status`, {
+          headers: {
+            'x-api-key': this.apiKey,
+            'anthropic-version': '2023-06-01'
+          }
+        });
+
+        if (!response.ok) {
+          throw new Error(`Failed to get session status: ${response.status}`);
+        }
+
+        const data = await response.json() as { status: RemoteSessionConfig['status']; last_activity: string };
+        
+        const session = this.sessions.get(sessionId);
+        if (session) {
+          const oldStatus = session.status;
+          session.status = data.status;
+          session.lastActivity = new Date(data.last_activity);
+
+          if (oldStatus !== data.status) {
+            this.emit('session:status', session);
+          }
+        }
+      } catch (error) {
+        log.error(`Failed to poll session ${sessionId}:`, error);
+      }
+    }, 30000);
+
+    this.pollIntervals.set(sessionId, interval);
+  }
+
+  private stopPolling(sessionId: string): void {
+    const interval = this.pollIntervals.get(sessionId);
+    if (interval) {
+      clearInterval(interval);
+      this.pollIntervals.delete(sessionId);
+    }
+  }
+
+  cleanup(): void {
+    for (const sessionId of this.pollIntervals.keys()) {
+      this.stopPolling(sessionId);
+    }
+    this.sessions.clear();
+  }
+}
+
+export default RemoteSessionManager;