4ME - Personal OS (Productivity OS)

4ME/
├── apps/
│   ├── core-api/               # NestJS Backend (The Kernel)
│   │   ├── src/
│   │   │   ├── plugins/       # Plugin loader & registry
│   │   │   ├── auth/          # JWT authentication
│   │   │   ├── ai/            # Gemini AI integration
│   │   │   ├── sync/           # Yjs CRDT sync gateway
│   │   │   └── plugins/       # Individual plugin modules
│   │   └── prisma/            # Database schema
│   │
│   ├── web/                    # Next.js Frontend (The Shell)
│   │   ├── src/app/          # App Router pages
│   │   ├── components/        # React components
│   │   └── lib/              # Utilities & API client
│   │
│   ├── desktop/               # Native Desktop (Tauri v2)
│   │   ├── src/              # Rust + React
│   │   └── tauri.conf.json   # Tauri configuration
│   │
│   ├── cli/                   # Hardened CLI Power Tool
│   │   └── src/              # TypeScript CLI
│   │
│   ├── vscode-extension/      # VS Code Extension
│   │   └── src/              # Extension & Activity tracking
│   │
│   └── chrome-extension/      # Chrome Extension (Manifest V3)
│       └── src/              # Browser activity tracker
│
├── packages/
│   └── plugin-sdk/            # TypeScript contracts for plugins
│
├── plugins/
│   ├── time-tracker/          # Time tracking, invoicing, forecasting
│   ├── life-log/             # Passive activity recording
│   ├── system-health/        # Real-time system monitoring
│   ├── appearance/           # Theme engine with customization
│   └── hello-world/          # Basic proof of concept
│
└── docker-compose.yml         # Infrastructure

// Plugin SDK Interface
interface Plugin {
  name: string;
  version: string;
  routes?: RouteDefinition[];
  apiHandlers?: ApiHandler[];
  permissions: string[];
  init(context: PluginContext): Promise<void>;
}

// Core API loads plugins dynamically
async function loadPlugins() {
  const plugins = await PluginRegistry.discover();
  for (const plugin of plugins) {
    await plugin.init(coreContext);
    router.register(plugin.routes);
  }
}

// AI Service with RAG support
class AIService {
  private model: GenerativeModel;
  private vectorStore: VectorStore;
  
  async chat(prompt: string, context: UserContext) {
    // Retrieve relevant context from vector store
    const relevantDocs = await this.vectorStore.similaritySearch(prompt);
    
    // Build enhanced prompt with context
    const enhancedPrompt = this.buildPrompt(prompt, relevantDocs);
    
    // Generate response
    const response = await this.model.generateContent(enhancedPrompt);
    return response.text();
  }
}

// WebSocket Sync Gateway
@WebSocketGateway('/sync', { namespace: 'sync' })
class SyncGateway {
  @SubscribeMessage('sync')
  handleSync(client: Socket, payload: Uint8Array) {
    // Apply CRDT update
    const doc = this.getDocument(client.userId);
    doc.applyUpdate(payload);
    
    // Broadcast to other clients
    client.broadcast.to(client.room).emit('sync', payload);
  }
}

// User & Auth
model User {
  id            String   @id @default(uuid())
  email         String   @unique
  passwordHash  String
  name          String?
  settings      Json?
  createdAt     DateTime @default(now())
}

// Time Tracking
model Project {
  id          String   @id @default(uuid())
  name        String
  color       String?
  userId      String
  tasks       Task[]
  timeEntries TimeEntry[]
}

// Activity Logging
model ActivityLog {
  id          String   @id @default(uuid())
  userId      String
  action      String
  metadata    Json?
  timestamp   DateTime @default(now())
}

// Plugins
model PluginConfig {
  id        String   @id @default(uuid())
  pluginId  String
  userId    String
  config    Json
}

services:
  postgres:
    image: postgres:15-alpine
    ports:
      - "5433:5432"  # Avoid port conflicts

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

  minio:
    image: minio/minio
    ports:
      - "9000:9000"
      - "9001:9001"

# Install dependencies
npm install

# Start infrastructure
docker compose up -d

# Build project
npm run build

# Start Core API
node apps/core-api/dist/apps/core-api/src/main.js

# Start Web Frontend
npm run dev --filter=web

# Desktop App
cd apps/desktop
npm run tauri dev

# Verify Phase 1 (Auth & API)
npm run verify-phase1

# Verify PII Redaction
npm run verify-pii

# Login
node apps/cli/dist/main.js login [email protected] password

# Check status
node apps/cli/dist/main.js status

// PII Detection patterns
const PII_PATTERNS = {
  email: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g,
  ipv4: /(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)/g,
  phone: /\b\d{10,}\b/g,
  creditCard: /\b(?:\d{4}[- ]?){3}\d{4}\b/g,
  secret: /(?:api[_-]?key|secret[_-]?token|password)\s*[=:]\s*["']?([\w-]{20,})["']?/gi
};

class DataSanitizer {
  sanitize(input: string): string {
    let result = input;
    for (const [type, pattern] of Object.entries(PII_PATTERNS)) {
      result = result.replace(pattern, `[REDACTED_${type.toUpperCase()}]`);
    }
    return result;
  }
}

// Token generation with short-lived access tokens
class TokenService {
  generateAccessToken(user: User): string {
    return jwt.sign(
      { sub: user.id, email: user.email, type: 'access' },
      process.env.JWT_SECRET,
      { expiresIn: '15m' }
    );
  }

  generateRefreshToken(user: User): string {
    return jwt.sign(
      { sub: user.id, type: 'refresh', jti: uuid() },
      process.env.JWT_SECRET,
      { expiresIn: '7d' }
    );
  }
}

// plugins/my-custom-plugin/src/index.ts
import { Plugin, PluginContext } from '@4me/plugin-sdk';

export const myPlugin: Plugin = {
  name: 'my-custom-plugin',
  version: '1.0.0',
  description: 'Custom plugin for specialized functionality',
  
  permissions: [
    { resource: 'data', actions: ['read', 'write'] },
    { resource: 'ai', actions: ['read'] }
  ],

  routes: [
    {
      method: 'GET',
      path: '/my-plugin/status',
      handler: async (req, res) => {
        const status = await getPluginStatus(req.user.id);
        res.json(status);
      }
    }
  ],

  async init(context: PluginContext) {
    console.log(`Initializing ${this.name} for user ${context.userId}`);
    await this.registerEventHandlers(context);
  }
};

// Optimized data fetching
class TimeEntryService {
  async getEntriesWithProjects(userId: string, dateRange: DateRange) {
    return this.prisma.timeEntry.findMany({
      where: {
        userId,
        startTime: { gte: dateRange.start, lte: dateRange.end }
      },
      include: {
        project: { select: { id: true, name: true, color: true } },
        tags: true
      },
      orderBy: { startTime: 'desc' }
    });
  }
}

class CacheService {
  async getOrSet<T>(key: string, factory: () => Promise<T>, ttl: number): Promise<T> {
    const cached = await this.redis.get(key);
    if (cached) return JSON.parse(cached);
    
    const value = await factory();
    await this.redis.setex(key, ttl, JSON.stringify(value));
    return value;
  }
}