lean-claudient-daemon 0.1.0

package/src/api.ts

@@ -0,0 +1,58 @@
+import { Router } from 'express';
+import { MetricsStore } from './metricsStore.js';
+
+export function createApiRouter(store: MetricsStore): Router {
+  const router = Router();
+
+  router.get('/status', (req, res) => {
+    const uptime = process.uptime();
+    const memory = process.memoryUsage().heapUsed / 1024 / 1024;
+    res.json({
+      running: true,
+      uptime: Math.floor(uptime),
+      memory: parseFloat(memory.toFixed(2)),
+      pid: process.pid,
+    });
+  });
+
+  router.get('/metrics', async (req, res) => {
+    try {
+      const metrics = await store.getAggregateMetrics();
+      res.json(metrics);
+    } catch (error) {
+      res.status(500).json({ error: 'Failed to retrieve metrics' });
+    }
+  });
+
+  router.get('/budget/:sessionId', async (req, res) => {
+    try {
+      const budget = await store.getBudgetStatus(req.params.sessionId);
+      if (!budget) {
+        return res.status(404).json({ error: 'Session not found' });
+      }
+      res.json(budget);
+    } catch (error) {
+      res.status(500).json({ error: 'Failed to retrieve budget' });
+    }
+  });
+
+  router.get('/sessions', async (req, res) => {
+    try {
+      const sessions = await store.getAllSessions();
+      res.json(sessions);
+    } catch (error) {
+      res.status(500).json({ error: 'Failed to retrieve sessions' });
+    }
+  });
+
+  router.post('/sessions/:id/checkpoint', async (req, res) => {
+    try {
+      await store.saveCheckpoint(req.params.id, req.body.checkpoint);
+      res.json({ saved: true });
+    } catch (error) {
+      res.status(500).json({ error: 'Failed to save checkpoint' });
+    }
+  });
+
+  return router;
+}

package/src/bin/daemon.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { LeanClaudientDaemon } from '../service.js';
+
+const program = new Command();
+
+program
+  .name('lean-claudient-daemon')
+  .version('0.1.0')
+  .option('-p, --port <port>', 'Port to listen on', '9831')
+  .option('-l, --log <path>', 'Log file path')
+  .action(async (options) => {
+    const daemon = new LeanClaudientDaemon(parseInt(options.port), options.log);
+    await daemon.start();
+  });
+
+program.parse();

package/src/metrics.ts

@@ -0,0 +1,45 @@
+export interface MetricsRecord {
+  sessionId: string;
+  timestamp: number;
+  inputTokens: number;
+  outputTokens: number;
+  totalTokens: number;
+  cost: number;
+  savedTokens: number;
+  compressionRatio: number;
+  subagentCount: number;
+}
+
+export function aggregateMetrics(records: MetricsRecord[]): any {
+  if (records.length === 0) {
+    return {
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalTokens: 0,
+      totalCost: '$0.00',
+      totalSavedTokens: 0,
+      averageCompressionRatio: 0,
+      sessionCount: 0,
+      averageSubagentCount: 0,
+    };
+  }
+
+  const totalInputTokens = records.reduce((sum, r) => sum + r.inputTokens, 0);
+  const totalOutputTokens = records.reduce((sum, r) => sum + r.outputTokens, 0);
+  const totalTokens = totalInputTokens + totalOutputTokens;
+  const totalCost = totalInputTokens * 0.000003 + totalOutputTokens * 0.000015;
+  const totalSavedTokens = records.reduce((sum, r) => sum + r.savedTokens, 0);
+  const avgCompressionRatio = records.reduce((sum, r) => sum + r.compressionRatio, 0) / records.length;
+  const avgSubagentCount = records.reduce((sum, r) => sum + r.subagentCount, 0) / records.length;
+
+  return {
+    totalInputTokens,
+    totalOutputTokens,
+    totalTokens,
+    totalCost: `$${totalCost.toFixed(2)}`,
+    totalSavedTokens,
+    averageCompressionRatio: parseFloat(avgCompressionRatio.toFixed(2)),
+    sessionCount: records.length,
+    averageSubagentCount: Math.round(avgSubagentCount),
+  };
+}

package/src/metricsStore.ts

@@ -0,0 +1,114 @@
+import sqlite3 from 'sqlite3';
+import { promisify } from 'util';
+import path from 'path';
+import fs from 'fs';
+import { MetricsRecord, aggregateMetrics } from './metrics.js';
+
+export class MetricsStore {
+  private db?: sqlite3.Database;
+  private dbPath: string;
+
+  constructor(dbPath?: string) {
+    this.dbPath = dbPath || path.join(process.env.HOME!, '.lean-claudient', 'daemon.db');
+  }
+
+  async initialize() {
+    const dir = path.dirname(this.dbPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    this.db = new sqlite3.Database(this.dbPath);
+
+    const run = promisify(this.db.run.bind(this.db));
+    await run(`
+      CREATE TABLE IF NOT EXISTS metrics (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        sessionId TEXT NOT NULL,
+        timestamp INTEGER NOT NULL,
+        inputTokens INTEGER,
+        outputTokens INTEGER,
+        cost REAL,
+        savedTokens INTEGER,
+        compressionRatio REAL,
+        subagentCount INTEGER,
+        UNIQUE(sessionId, timestamp)
+      )
+    `);
+
+    await run(`
+      CREATE TABLE IF NOT EXISTS checkpoints (
+        sessionId TEXT PRIMARY KEY,
+        checkpoint TEXT NOT NULL,
+        timestamp INTEGER NOT NULL
+      )
+    `);
+  }
+
+  async recordMetrics(metrics: MetricsRecord) {
+    const run = promisify(this.db!.run.bind(this.db!));
+    await run(
+      `INSERT OR REPLACE INTO metrics (sessionId, timestamp, inputTokens, outputTokens, cost, savedTokens, compressionRatio, subagentCount)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        metrics.sessionId,
+        metrics.timestamp,
+        metrics.inputTokens,
+        metrics.outputTokens,
+        metrics.cost,
+        metrics.savedTokens,
+        metrics.compressionRatio,
+        metrics.subagentCount,
+      ]
+    );
+  }
+
+  async getAggregateMetrics() {
+    const all = promisify(this.db!.all.bind(this.db!));
+    const records = (await all(
+      'SELECT * FROM metrics WHERE timestamp > ? ORDER BY timestamp DESC LIMIT 1000',
+      [Date.now() - 7 * 24 * 60 * 60 * 1000]
+    )) as MetricsRecord[];
+
+    return aggregateMetrics(records);
+  }
+
+  async getBudgetStatus(sessionId: string) {
+    const get = promisify(this.db!.get.bind(this.db!));
+    const record = (await get(
+      'SELECT * FROM metrics WHERE sessionId = ? ORDER BY timestamp DESC LIMIT 1',
+      [sessionId]
+    )) as MetricsRecord | undefined;
+
+    if (!record) return null;
+
+    return {
+      sessionId,
+      spent: record.cost,
+      limit: 500,
+      remaining: 500 - record.cost,
+      alert: record.cost > 375 ? 'warning' : 'ok',
+    };
+  }
+
+  async getAllSessions() {
+    const all = promisify(this.db!.all.bind(this.db!));
+    return (await all(
+      'SELECT DISTINCT sessionId, MIN(timestamp) as startTime, COUNT(*) as recordCount FROM metrics GROUP BY sessionId'
+    )) as any[];
+  }
+
+  async saveCheckpoint(sessionId: string, checkpoint: string) {
+    const run = promisify(this.db!.run.bind(this.db!));
+    await run(
+      'INSERT OR REPLACE INTO checkpoints (sessionId, checkpoint, timestamp) VALUES (?, ?, ?)',
+      [sessionId, checkpoint, Date.now()]
+    );
+  }
+
+  async close() {
+    return new Promise<void>((resolve, reject) => {
+      this.db!.close((err) => (err ? reject(err) : resolve()));
+    });
+  }
+}

package/src/middleware/rateLimiting.ts

@@ -0,0 +1,244 @@
+/**
+ * Rate Limiting Middleware
+ * Prevents DOS attacks by limiting requests per IP and session
+ */
+
+import { Request, Response, NextFunction } from 'express';
+
+/**
+ * Rate limit store - stores request counts by key
+ * Key format: "ip:address" or "session:sessionId"
+ */
+class RateLimitStore {
+  private store: Map<string, { count: number; resetTime: number }> = new Map();
+  private cleanupInterval: NodeJS.Timeout;
+
+  constructor() {
+    // Clean up expired entries every minute
+    this.cleanupInterval = setInterval(() => {
+      const now = Date.now();
+      for (const [key, value] of this.store.entries()) {
+        if (value.resetTime < now) {
+          this.store.delete(key);
+        }
+      }
+    }, 60000);
+  }
+
+  /**
+   * Record a request and return remaining quota
+   */
+  recordRequest(key: string, windowMs: number, limit: number): number {
+    const now = Date.now();
+    const entry = this.store.get(key);
+
+    if (!entry || entry.resetTime < now) {
+      this.store.set(key, { count: 1, resetTime: now + windowMs });
+      return limit - 1;
+    }
+
+    entry.count++;
+    return Math.max(0, limit - entry.count);
+  }
+
+  /**
+   * Check if limit is exceeded
+   */
+  isLimited(key: string, windowMs: number, limit: number): boolean {
+    const now = Date.now();
+    const entry = this.store.get(key);
+
+    if (!entry || entry.resetTime < now) {
+      return false;
+    }
+
+    return entry.count >= limit;
+  }
+
+  /**
+   * Get remaining time until reset
+   */
+  getResetTime(key: string): number {
+    const entry = this.store.get(key);
+    if (!entry) return 0;
+    return Math.max(0, entry.resetTime - Date.now());
+  }
+
+  /**
+   * Cleanup
+   */
+  destroy(): void {
+    clearInterval(this.cleanupInterval);
+    this.store.clear();
+  }
+}
+
+const globalStore = new RateLimitStore();
+
+/**
+ * Rate limiting configuration
+ */
+interface RateLimitConfig {
+  windowMs: number; // Time window in milliseconds
+  max: number; // Max requests per window
+  keyGenerator?: (req: Request) => string;
+  handler?: (req: Request, res: Response) => void;
+  skip?: (req: Request) => boolean;
+  onLimitReached?: (req: Request, key: string) => void;
+}
+
+/**
+ * Create rate limit middleware
+ */
+export function rateLimit(config: RateLimitConfig) {
+  const {
+    windowMs = 15 * 60 * 1000, // 15 minutes default
+    max = 100,
+    keyGenerator = (req) => `ip:${req.ip}`,
+    skip,
+    onLimitReached,
+  } = config;
+
+  return (req: Request, res: Response, next: NextFunction) => {
+    if (skip && skip(req)) {
+      return next();
+    }
+
+    const key = keyGenerator(req);
+    const remaining = globalStore.recordRequest(key, windowMs, max);
+    const isLimited = globalStore.isLimited(key, windowMs, max);
+    const resetTime = globalStore.getResetTime(key);
+
+    // Set rate limit headers
+    res.setHeader('X-RateLimit-Limit', max);
+    res.setHeader('X-RateLimit-Remaining', Math.max(0, remaining));
+    res.setHeader('X-RateLimit-Reset', Math.ceil((Date.now() + resetTime) / 1000));
+
+    if (isLimited) {
+      res.setHeader('Retry-After', Math.ceil(resetTime / 1000));
+
+      if (onLimitReached) {
+        onLimitReached(req, key);
+      }
+
+      return res.status(429).json({
+        error: 'Too Many Requests',
+        code: 'RATE_LIMIT_EXCEEDED',
+        details: {
+          retryAfter: Math.ceil(resetTime / 1000),
+          limit: max,
+          windowMs,
+        },
+      });
+    }
+
+    next();
+  };
+}
+
+/**
+ * Generic rate limiter by key
+ */
+export function createRateLimiter(config: RateLimitConfig) {
+  return rateLimit(config);
+}
+
+/**
+ * Rate limiter by IP address
+ */
+export function createIPRateLimiter(maxRequests: number, windowMinutes: number = 15) {
+  return rateLimit({
+    windowMs: windowMinutes * 60 * 1000,
+    max: maxRequests,
+    keyGenerator: (req) => `ip:${req.ip || 'unknown'}`,
+  });
+}
+
+/**
+ * Rate limiter by session ID
+ */
+export function createSessionRateLimiter(maxRequests: number, windowMinutes: number = 15) {
+  return rateLimit({
+    windowMs: windowMinutes * 60 * 1000,
+    max: maxRequests,
+    keyGenerator: (req) => {
+      const sessionId = req.params.sessionId || req.query.sessionId;
+      return `session:${sessionId || 'unknown'}`;
+    },
+  });
+}
+
+/**
+ * Rate limiter by user ID (from query or body)
+ */
+export function createUserRateLimiter(maxRequests: number, windowMinutes: number = 15) {
+  return rateLimit({
+    windowMs: windowMinutes * 60 * 1000,
+    max: maxRequests,
+    keyGenerator: (req) => {
+      const userId = (req.query.userId as string) || (req.body as any)?.userId;
+      return `user:${userId || 'anonymous'}`;
+    },
+  });
+}
+
+/**
+ * Tiered rate limiter configuration
+ * Different limits for different endpoints
+ */
+export const RATE_LIMITS = {
+  // High frequency - status checks
+  STATUS: { max: 100, windowMinutes: 1 },
+
+  // Medium frequency - metrics reads
+  METRICS: { max: 60, windowMinutes: 1 },
+
+  // Medium frequency - budget checks
+  BUDGET: { max: 60, windowMinutes: 1 },
+
+  // Low frequency - session creation
+  SESSIONS: { max: 30, windowMinutes: 1 },
+
+  // Very low frequency - checkpoints
+  CHECKPOINT: { max: 10, windowMinutes: 1 },
+
+  // Low frequency - admin operations
+  ADMIN: { max: 20, windowMinutes: 1 },
+};
+
+/**
+ * Create logging function for rate limit violations
+ */
+export function createRateLimitLogger(logFile?: string) {
+  return (req: Request, key: string) => {
+    const logEntry = {
+      timestamp: new Date().toISOString(),
+      key,
+      method: req.method,
+      path: req.path,
+      ip: req.ip,
+      userAgent: req.get('User-Agent'),
+    };
+
+    if (logFile) {
+      // Would log to file in production
+      console.warn('[RATE_LIMIT]', JSON.stringify(logEntry));
+    } else {
+      console.warn('[RATE_LIMIT]', logEntry);
+    }
+  };
+}
+
+/**
+ * Cleanup rate limiter
+ */
+export function destroyRateLimiter(): void {
+  globalStore.destroy();
+}
+
+/**
+ * Reset rate limiter for testing
+ */
+export function resetRateLimiter(): void {
+  destroyRateLimiter();
+}