codex-linux 1.0.0

package/supabase/schema.sql

@@ -0,0 +1,234 @@
+-- Supabase Database Schema for Codex Linux Cloud Sync
+-- Run this in your Supabase SQL Editor
+
+-- Enable realtime for threads table
+alter publication supabase_realtime add table threads;
+
+-- Create threads table
+CREATE TABLE IF NOT EXISTS threads (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    agent_id UUID NOT NULL,
+    user_id UUID NOT NULL,
+    device_id TEXT NOT NULL,
+    project_path TEXT NOT NULL,
+    messages JSONB NOT NULL DEFAULT '[]',
+    status TEXT NOT NULL DEFAULT 'idle',
+    last_modified BIGINT NOT NULL DEFAULT EXTRACT(EPOCH FROM NOW()) * 1000,
+    version INTEGER NOT NULL DEFAULT 1,
+    is_deleted BOOLEAN NOT NULL DEFAULT FALSE,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+-- Create indexes for better performance
+CREATE INDEX IF NOT EXISTS idx_threads_user_id ON threads(user_id);
+CREATE INDEX IF NOT EXISTS idx_threads_agent_id ON threads(agent_id);
+CREATE INDEX IF NOT EXISTS idx_threads_device_id ON threads(device_id);
+CREATE INDEX IF NOT EXISTS idx_threads_last_modified ON threads(last_modified);
+CREATE INDEX IF NOT EXISTS idx_threads_user_deleted ON threads(user_id, is_deleted);
+
+-- Create users table for cloud sync
+CREATE TABLE IF NOT EXISTS cloud_users (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    email TEXT UNIQUE NOT NULL,
+    display_name TEXT,
+    avatar_url TEXT,
+    devices JSONB NOT NULL DEFAULT '[]',
+    settings JSONB NOT NULL DEFAULT '{}',
+    subscription_tier TEXT DEFAULT 'free',
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+-- Create devices table to track user devices
+CREATE TABLE IF NOT EXISTS user_devices (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    user_id UUID NOT NULL REFERENCES cloud_users(id) ON DELETE CASCADE,
+    device_id TEXT NOT NULL,
+    device_name TEXT NOT NULL,
+    device_type TEXT NOT NULL,
+    last_sync BIGINT,
+    is_active BOOLEAN NOT NULL DEFAULT TRUE,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+    UNIQUE(user_id, device_id)
+);
+
+-- Create sync conflicts table for manual resolution
+CREATE TABLE IF NOT EXISTS sync_conflicts (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    thread_id UUID NOT NULL REFERENCES threads(id) ON DELETE CASCADE,
+    user_id UUID NOT NULL,
+    local_version JSONB NOT NULL,
+    remote_version JSONB NOT NULL,
+    resolution TEXT,
+    resolved_at TIMESTAMP WITH TIME ZONE,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+-- Row Level Security (RLS) Policies
+
+-- Enable RLS on all tables
+ALTER TABLE threads ENABLE ROW LEVEL SECURITY;
+ALTER TABLE cloud_users ENABLE ROW LEVEL SECURITY;
+ALTER TABLE user_devices ENABLE ROW LEVEL SECURITY;
+ALTER TABLE sync_conflicts ENABLE ROW LEVEL SECURITY;
+
+-- Threads policies
+CREATE POLICY "Users can only access their own threads"
+    ON threads FOR ALL
+    USING (user_id = auth.uid());
+
+-- Cloud users policies
+CREATE POLICY "Users can only access their own profile"
+    ON cloud_users FOR ALL
+    USING (id = auth.uid());
+
+-- User devices policies
+CREATE POLICY "Users can only access their own devices"
+    ON user_devices FOR ALL
+    USING (user_id = auth.uid());
+
+-- Sync conflicts policies
+CREATE POLICY "Users can only access their own conflicts"
+    ON sync_conflicts FOR ALL
+    USING (user_id = auth_uid());
+
+-- Functions
+
+-- Function to update the updated_at timestamp
+CREATE OR REPLACE FUNCTION update_updated_at_column()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_at = NOW();
+    RETURN NEW;
+END;
+$$ language 'plpgsql';
+
+-- Triggers for updated_at
+CREATE TRIGGER update_threads_updated_at
+    BEFORE UPDATE ON threads
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();
+
+CREATE TRIGGER update_cloud_users_updated_at
+    BEFORE UPDATE ON cloud_users
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();
+
+-- Function to get threads modified since a timestamp
+CREATE OR REPLACE FUNCTION get_threads_since(
+    p_user_id UUID,
+    p_since BIGINT
+)
+RETURNS TABLE (
+    id UUID,
+    agent_id UUID,
+    user_id UUID,
+    device_id TEXT,
+    project_path TEXT,
+    messages JSONB,
+    status TEXT,
+    last_modified BIGINT,
+    version INTEGER,
+    is_deleted BOOLEAN,
+    created_at TIMESTAMP WITH TIME ZONE,
+    updated_at TIMESTAMP WITH TIME ZONE
+) AS $$
+BEGIN
+    RETURN QUERY
+    SELECT t.*
+    FROM threads t
+    WHERE t.user_id = p_user_id
+    AND t.last_modified > p_since
+    AND t.is_deleted = FALSE
+    ORDER BY t.last_modified DESC;
+END;
+$$ LANGUAGE plpgsql SECURITY DEFINER;
+
+-- Function to upsert thread with conflict detection
+CREATE OR REPLACE FUNCTION upsert_thread(
+    p_id UUID,
+    p_agent_id UUID,
+    p_user_id UUID,
+    p_device_id TEXT,
+    p_project_path TEXT,
+    p_messages JSONB,
+    p_status TEXT,
+    p_last_modified BIGINT,
+    p_version INTEGER,
+    p_is_deleted BOOLEAN
+)
+RETURNS JSONB AS $$
+DECLARE
+    existing_version INTEGER;
+    result JSONB;
+BEGIN
+    -- Check if thread exists and get its version
+    SELECT version INTO existing_version
+    FROM threads
+    WHERE id = p_id;
+    
+    IF existing_version IS NULL THEN
+        -- Insert new thread
+        INSERT INTO threads (
+            id, agent_id, user_id, device_id, project_path,
+            messages, status, last_modified, version, is_deleted
+        ) VALUES (
+            p_id, p_agent_id, p_user_id, p_device_id, p_project_path,
+            p_messages, p_status, p_last_modified, p_version, p_is_deleted
+        );
+        
+        result := jsonb_build_object(
+            'success', true,
+            'action', 'insert',
+            'conflict', false
+        );
+    ELSIF p_version > existing_version THEN
+        -- Update with newer version
+        UPDATE threads SET
+            agent_id = p_agent_id,
+            device_id = p_device_id,
+            project_path = p_project_path,
+            messages = p_messages,
+            status = p_status,
+            last_modified = p_last_modified,
+            version = p_version,
+            is_deleted = p_is_deleted
+        WHERE id = p_id;
+        
+        result := jsonb_build_object(
+            'success', true,
+            'action', 'update',
+            'conflict', false
+        );
+    ELSE
+        -- Version conflict detected
+        INSERT INTO sync_conflicts (
+            thread_id, user_id, local_version, remote_version
+        ) VALUES (
+            p_id, p_user_id,
+            (SELECT to_jsonb(t.*) FROM threads t WHERE t.id = p_id),
+            jsonb_build_object(
+                'id', p_id,
+                'agent_id', p_agent_id,
+                'device_id', p_device_id,
+                'project_path', p_project_path,
+                'messages', p_messages,
+                'status', p_status,
+                'last_modified', p_last_modified,
+                'version', p_version,
+                'is_deleted', p_is_deleted
+            )
+        );
+        
+        result := jsonb_build_object(
+            'success', false,
+            'action', 'none',
+            'conflict', true,
+            'message', 'Version conflict detected. Manual resolution required.'
+        );
+    END IF;
+    
+    RETURN result;
+END;
+$$ LANGUAGE plpgsql SECURITY DEFINER;

package/tailwind.config.js

@@ -0,0 +1,78 @@
+/** @type {import('tailwindcss').Config} */
+module.exports = {
+  darkMode: ["class"],
+  content: [
+    './index.html',
+    './src/renderer/**/*.{js,ts,jsx,tsx}',
+  ],
+  theme: {
+    container: {
+      center: true,
+      padding: "2rem",
+      screens: {
+        "2xl": "1400px",
+      },
+    },
+    extend: {
+      colors: {
+        border: "hsl(var(--border))",
+        input: "hsl(var(--input))",
+        ring: "hsl(var(--ring))",
+        background: "hsl(var(--background))",
+        foreground: "hsl(var(--foreground))",
+        primary: {
+          DEFAULT: "hsl(var(--primary))",
+          foreground: "hsl(var(--primary-foreground))",
+        },
+        secondary: {
+          DEFAULT: "hsl(var(--secondary))",
+          foreground: "hsl(var(--secondary-foreground))",
+        },
+        destructive: {
+          DEFAULT: "hsl(var(--destructive))",
+          foreground: "hsl(var(--destructive-foreground))",
+        },
+        muted: {
+          DEFAULT: "hsl(var(--muted))",
+          foreground: "hsl(var(--muted-foreground))",
+        },
+        accent: {
+          DEFAULT: "hsl(var(--accent))",
+          foreground: "hsl(var(--accent-foreground))",
+        },
+        popover: {
+          DEFAULT: "hsl(var(--popover))",
+          foreground: "hsl(var(--popover-foreground))",
+        },
+        card: {
+          DEFAULT: "hsl(var(--card))",
+          foreground: "hsl(var(--card-foreground))",
+        },
+      },
+      borderRadius: {
+        lg: "var(--radius)",
+        md: "calc(var(--radius) - 2px)",
+        sm: "calc(var(--radius) - 4px)",
+      },
+      fontFamily: {
+        sans: ['Inter', 'system-ui', '-apple-system', 'BlinkMacSystemFont', 'Segoe UI', 'Roboto', 'sans-serif'],
+        mono: ['JetBrains Mono', 'Fira Code', 'Menlo', 'Monaco', 'Consolas', 'monospace'],
+      },
+      keyframes: {
+        "accordion-down": {
+          from: { height: "0" },
+          to: { height: "var(--radix-accordion-content-height)" },
+        },
+        "accordion-up": {
+          from: { height: "var(--radix-accordion-content-height)" },
+          to: { height: "0" },
+        },
+      },
+      animation: {
+        "accordion-down": "accordion-down 0.2s ease-out",
+        "accordion-up": "accordion-up 0.2s ease-out",
+      },
+    },
+  },
+  plugins: [require("tailwindcss-animate")],
+}

package/tests/e2e/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@codex-linux/e2e",
+  "version": "1.0.0",
+  "private": true,
+  "scripts": {
+    "test": "playwright test",
+    "test:ui": "playwright test --ui",
+    "test:debug": "playwright test --debug",
+    "report": "playwright show-report"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.40.0",
+    "@types/node": "^20.10.0"
+  }
+}

package/tests/e2e/playwright.config.ts

@@ -0,0 +1,31 @@
+import { defineConfig, devices } from '@playwright/test';
+
+export default defineConfig({
+  testDir: './specs',
+  fullyParallel: true,
+  forbidOnly: !!process.env.CI,
+  retries: process.env.CI ? 2 : 0,
+  workers: process.env.CI ? 1 : undefined,
+  reporter: 'html',
+  use: {
+    baseURL: 'http://localhost:3000',
+    trace: 'on-first-retry',
+    screenshot: 'only-on-failure',
+    video: 'retain-on-failure',
+  },
+  projects: [
+    {
+      name: 'chromium',
+      use: { ...devices['Desktop Chrome'] },
+    },
+    {
+      name: 'firefox',
+      use: { ...devices['Desktop Firefox'] },
+    },
+  ],
+  webServer: {
+    command: 'cd ../.. && npm run dev',
+    url: 'http://localhost:3000',
+    reuseExistingServer: !process.env.CI,
+  },
+});

package/tests/e2e/specs/app.spec.ts

@@ -0,0 +1,194 @@
+import { test, expect, type Page } from '@playwright/test';
+
+test.describe('Codex Linux E2E Tests', () => {
+  
+  test.beforeEach(async ({ page }) => {
+    await page.goto('/');
+    await page.waitForLoadState('networkidle');
+  });
+
+  describe('Application Launch', () => {
+    test('should display loading screen', async ({ page }) => {
+      await expect(page.locator('text=Loading')).toBeVisible({ timeout: 10000 });
+    });
+
+    test('should load main interface within timeout', async ({ page }) => {
+      await expect(page.locator('nav, aside, [class*="sidebar"]')).toBeVisible({ timeout: 30000 });
+    });
+
+    test('should have correct window title', async ({ page }) => {
+      await expect(page).toHaveTitle(/Codex/i, { timeout: 10000 });
+    });
+
+    test('should show sidebar navigation', async ({ page }) => {
+      await expect(page.locator('text=Agents')).toBeVisible({ timeout: 30000 });
+    });
+  });
+
+  describe('Navigation', () => {
+    test.beforeEach(async ({ page }) => {
+      await page.waitForSelector('text=Agents', { timeout: 30000 });
+    });
+
+    test('should navigate to all main sections', async ({ page }) => {
+      const sections = ['Agents', 'Worktrees', 'Skills', 'Settings'];
+      
+      for (const section of sections) {
+        await expect(page.locator(`text=${section}`)).toBeVisible();
+      }
+    });
+
+    test('should navigate using keyboard shortcuts', async ({ page }) => {
+      await page.keyboard.press('Alt+1');
+      await expect(page.locator('[class*="agent"]')).toBeVisible({ timeout: 5000 });
+    });
+  });
+
+  describe('Agent Management', () => {
+    test.beforeEach(async ({ page }) => {
+      await page.goto('/');
+      await page.waitForSelector('text=Agents', { timeout: 30000 });
+    });
+
+    test('should open create agent modal', async ({ page }) => {
+      const createButton = page.locator('[data-testid="create-agent-button"], button:has-text("Create")').first();
+      if (await createButton.isVisible()) {
+        await createButton.click();
+        await expect(page.locator('text=Create New Agent, text=New Agent')).toBeVisible({ timeout: 5000 });
+      }
+    });
+
+    test('should display agent list', async ({ page }) => {
+      await page.waitForTimeout(2000);
+      const agentCards = page.locator('[class*="card"], [class*="agent"]');
+      const count = await agentCards.count();
+      expect(count).toBeGreaterThanOrEqual(0);
+    });
+
+    test('should select an agent', async ({ page }) => {
+      await page.waitForTimeout(2000);
+      const firstAgent = page.locator('[class*="card"], [class*="agent"]').first();
+      if (await firstAgent.isVisible()) {
+        await firstAgent.click();
+        await page.waitForTimeout(1000);
+      }
+    });
+  });
+
+  describe('Chat Interface', () => {
+    test.beforeEach(async ({ page }) => {
+      await page.goto('/');
+      await page.waitForSelector('text=Agents', { timeout: 30000 });
+    });
+
+    test('should display chat input', async ({ page }) => {
+      await page.waitForTimeout(2000);
+      const chatInput = page.locator('input[type="text"], textarea, [data-testid="chat-input"]').first();
+      await expect(chatInput).toBeVisible({ timeout: 5000 });
+    });
+
+    test('should type and send message', async ({ page }) => {
+      await page.waitForTimeout(2000);
+      const chatInput = page.locator('input[type="text"], textarea, [data-testid="chat-input"]').first();
+      
+      if (await chatInput.isVisible()) {
+        await chatInput.fill('test message');
+        await expect(chatInput).toHaveValue('test message');
+      }
+    });
+  });
+
+  describe('Settings', () => {
+    test.beforeEach(async ({ page }) => {
+      await page.goto('/');
+      await page.waitForSelector('text=Settings', { timeout: 30000 });
+      await page.click('text=Settings');
+    });
+
+    test('should display settings page', async ({ page }) => {
+      await expect(page.locator('text=Settings, h1:has-text("Settings")')).toBeVisible({ timeout: 5000 });
+    });
+
+    test('should have general settings', async ({ page }) => {
+      await expect(page.locator('text=General, text=AI')).toBeVisible({ timeout: 5000 });
+    });
+  });
+
+  describe('Accessibility', () => {
+    test('should have proper heading structure', async ({ page }) => {
+      await page.goto('/');
+      await page.waitForSelector('text=Agents', { timeout: 30000 });
+      
+      const h1 = page.locator('h1');
+      const count = await h1.count();
+      expect(count).toBeGreaterThanOrEqual(0);
+    });
+
+    test('should have focusable elements', async ({ page }) => {
+      await page.goto('/');
+      await page.waitForSelector('text=Agents', { timeout: 30000 });
+      
+      const buttons = page.locator('button');
+      const count = await buttons.count();
+      expect(count).toBeGreaterThan(0);
+    });
+
+    test('should support keyboard navigation', async ({ page }) => {
+      await page.goto('/');
+      await page.waitForSelector('text=Agents', { timeout: 30000 });
+      
+      await page.keyboard.press('Tab');
+      const focusedElement = await page.locator(':focus').first();
+      await expect(focusedElement).toBeVisible();
+    });
+  });
+
+  describe('Error Handling', () => {
+    test('should handle network errors gracefully', async ({ page }) => {
+      await page.route('**/api/**', route => route.abort('failed'));
+      await page.goto('/');
+      await page.waitForTimeout(3000);
+      
+      const content = await page.content();
+      expect(content.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Responsive Design', () => {
+    test('should work at different viewport sizes', async ({ page }) => {
+      await page.setViewportSize({ width: 1920, height: 1080 });
+      await page.goto('/');
+      await expect(page.locator('text=Agents')).toBeVisible({ timeout: 30000 });
+
+      await page.setViewportSize({ width: 768, height: 1024 });
+      await page.reload();
+      await expect(page.locator('text=Agents')).toBeVisible({ timeout: 30000 });
+
+      await page.setViewportSize({ width: 375, height: 667 });
+      await page.reload();
+      await page.waitForTimeout(2000);
+    });
+  });
+
+  describe('Performance', () => {
+    test('should load within acceptable time', async ({ page }) => {
+      const startTime = Date.now();
+      await page.goto('/');
+      await page.waitForSelector('text=Agents', { timeout: 30000 });
+      const loadTime = Date.now() - startTime;
+      
+      console.log(`Page load time: ${loadTime}ms`);
+      expect(loadTime).toBeLessThan(30000);
+    });
+
+    test('should not have memory leaks on navigation', async ({ page }) => {
+      await page.goto('/');
+      await page.waitForSelector('text=Agents', { timeout: 30000 });
+      
+      for (let i = 0; i < 3; i++) {
+        await page.reload();
+        await page.waitForSelector('text=Agents', { timeout: 30000 });
+      }
+    });
+  });
+});

package/tests/setup.ts

@@ -0,0 +1,99 @@
+// Test setup and utilities
+
+// Mock electron modules
+jest.mock('electron', () => ({
+  app: {
+    getPath: () => '/tmp/test',
+    on: () => {},
+    whenReady: () => Promise.resolve(),
+  },
+  BrowserWindow: () => {},
+  ipcMain: {
+    handle: () => {},
+    on: () => {},
+  },
+  dialog: {
+    showOpenDialog: () => Promise.resolve({ filePaths: [] }),
+    showSaveDialog: () => Promise.resolve({ filePath: '' }),
+  },
+  shell: {
+    openExternal: () => Promise.resolve(),
+    openPath: () => Promise.resolve(''),
+  },
+  Notification: () => {},
+}));
+
+jest.mock('electron-log', () => ({
+  info: () => {},
+  error: () => {},
+  warn: () => {},
+  debug: () => {},
+}));
+
+jest.mock('electron-store', () => {
+  return () => ({
+    get: () => {},
+    set: () => {},
+    clear: () => {},
+  });
+});
+
+// Global test utilities
+(global as any).testUtils = {
+  createMockAgent: (overrides = {}) => ({
+    id: 'test-agent-1',
+    name: 'Test Agent',
+    status: 'idle',
+    projectPath: '/tmp/test-project',
+    worktreeName: 'test-worktree',
+    providerId: 'openai',
+    model: 'gpt-4o',
+    skills: [],
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    lastActiveAt: null,
+    messages: [],
+    tasks: [],
+    metadata: {},
+    ...overrides,
+  }),
+
+  createMockWorktree: (overrides = {}) => ({
+    name: 'test-worktree',
+    path: '/tmp/test-project/.codex/worktrees/test-worktree',
+    commit: 'abc123',
+    branch: 'codex/test-agent-1',
+    isMain: false,
+    agents: [],
+    createdAt: new Date(),
+    ...overrides,
+  }),
+
+  createMockSkill: (overrides = {}) => ({
+    id: 'test-skill-1',
+    name: 'Test Skill',
+    description: 'A test skill',
+    version: '1.0.0',
+    author: 'Test Author',
+    tags: ['test'],
+    files: [],
+    config: {
+      entryPoint: 'index.md',
+      parameters: [],
+      dependencies: [],
+      permissions: [],
+    },
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    ...overrides,
+  }),
+
+  wait: (ms: number) => new Promise(resolve => setTimeout(resolve, ms)),
+};
+
+// Console suppression for cleaner test output
+if (process.env.SUPPRESS_CONSOLE) {
+  console.log = () => {};
+  console.error = () => {};
+  console.warn = () => {};
+}