tlc-claude-code 0.9.6 → 0.9.8

package/dashboard/dist/components/ServicesPane.test.js

@@ -0,0 +1,103 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, it, expect } from 'vitest';
+import { render } from 'ink-testing-library';
+import { ServicesPane, formatUptime, getStatusInfo } from './ServicesPane.js';
+describe('ServicesPane', () => {
+    describe('formatUptime', () => {
+        it('returns dash for undefined', () => {
+            expect(formatUptime(undefined)).toBe('-');
+        });
+        it('formats seconds', () => {
+            expect(formatUptime(45000)).toBe('45s');
+        });
+        it('formats minutes and seconds', () => {
+            expect(formatUptime(125000)).toBe('2m 5s');
+        });
+        it('formats hours and minutes', () => {
+            expect(formatUptime(3700000)).toBe('1h 1m');
+        });
+    });
+    describe('getStatusInfo', () => {
+        it('returns healthy info when all running', () => {
+            const services = [
+                { name: 'api', state: 'running', health: 'healthy' },
+                { name: 'web', state: 'running', health: 'healthy' },
+            ];
+            const info = getStatusInfo(services);
+            expect(info.text).toContain('healthy');
+            expect(info.running).toBe(2);
+            expect(info.total).toBe(2);
+        });
+        it('returns stopped info when none running', () => {
+            const services = [
+                { name: 'api', state: 'stopped' },
+                { name: 'web', state: 'stopped' },
+            ];
+            const info = getStatusInfo(services);
+            expect(info.text).toBe('Stopped');
+            expect(info.running).toBe(0);
+        });
+        it('returns partial info when some running', () => {
+            const services = [
+                { name: 'api', state: 'running' },
+                { name: 'web', state: 'stopped' },
+            ];
+            const info = getStatusInfo(services);
+            expect(info.text).toContain('1/2');
+        });
+    });
+    describe('component rendering', () => {
+        it('renders empty state when no services', () => {
+            const { lastFrame } = render(_jsx(ServicesPane, { services: [], isActive: false }));
+            const output = lastFrame();
+            expect(output).toContain('No services');
+        });
+        it('renders service cards', () => {
+            const services = [
+                { name: 'api', type: 'express', port: 3001, state: 'running' },
+                { name: 'web', type: 'vite', port: 3000, state: 'running' },
+            ];
+            const { lastFrame } = render(_jsx(ServicesPane, { services: services, isActive: false }));
+            const output = lastFrame();
+            expect(output).toContain('api');
+            expect(output).toContain('web');
+            expect(output).toContain('express');
+            expect(output).toContain('vite');
+        });
+        it('shows stack status summary', () => {
+            const services = [
+                { name: 'api', type: 'express', port: 3001, state: 'running' },
+                { name: 'db', type: 'postgres', port: 5432, state: 'stopped' },
+            ];
+            const { lastFrame } = render(_jsx(ServicesPane, { services: services, isActive: false }));
+            const output = lastFrame();
+            expect(output).toContain('1/2');
+        });
+        it('shows state icons', () => {
+            const services = [
+                { name: 'api', type: 'express', port: 3001, state: 'running' },
+                { name: 'worker', type: 'node', port: 3002, state: 'stopped' },
+            ];
+            const { lastFrame } = render(_jsx(ServicesPane, { services: services, isActive: false }));
+            const output = lastFrame();
+            expect(output).toContain('🟢');
+            expect(output).toContain('⚪');
+        });
+        it('shows controls when active', () => {
+            const services = [
+                { name: 'api', type: 'express', port: 3001, state: 'running' },
+            ];
+            const { lastFrame } = render(_jsx(ServicesPane, { services: services, isActive: true }));
+            const output = lastFrame();
+            expect(output).toContain('[r]');
+        });
+        it('hides controls when inactive', () => {
+            const services = [
+                { name: 'api', type: 'express', port: 3001, state: 'running' },
+            ];
+            const { lastFrame } = render(_jsx(ServicesPane, { services: services, isActive: false }));
+            const output = lastFrame();
+            expect(output).not.toContain('[r] Restart');
+        });
+    });
+});

package/dashboard/package.json

@@ -11,7 +11,8 @@
     "build": "tsc",
     "start": "node dist/index.js",
     "test": "vitest run",
-    "test:watch": "vitest"
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
   },
   "dependencies": {
     "chalk": "^5.3.0",
@@ -25,6 +26,7 @@
     "@types/dockerode": "^3.3.31",
     "@types/node": "^22.10.0",
     "@types/react": "^18.3.12",
+    "@vitest/coverage-v8": "^4.0.18",
     "ink-testing-library": "^4.0.0",
     "memfs": "^4.56.10",
     "tsx": "^4.19.2",

package/docker-compose.dev.yml

@@ -37,6 +37,17 @@ services:
       - NODE_ENV=development
       - DATABASE_URL=postgres://postgres:postgres@db:5432/app
       - PORT=5001
+      # S3-compatible storage (MinIO)
+      - S3_ENDPOINT=http://storage:9000
+      - S3_ACCESS_KEY=minioadmin
+      - S3_SECRET_KEY=minioadmin
+      - S3_BUCKET=uploads
+      - S3_REGION=us-east-1
+      - S3_FORCE_PATH_STYLE=true
+      - AWS_ENDPOINT_URL_S3=http://storage:9000
+      - AWS_ACCESS_KEY_ID=minioadmin
+      - AWS_SECRET_ACCESS_KEY=minioadmin
+      - AWS_REGION=us-east-1
     ports:
       - "${APP_PORT:-5001}:5001"
     volumes:
@@ -60,6 +71,26 @@ services:
       - db
     restart: on-failure
 
+  # MinIO S3-Compatible Storage
+  storage:
+    image: minio/minio:latest
+    container_name: tlc-${COMPOSE_PROJECT_NAME:-dev}-storage
+    command: server /data --console-address ":9001"
+    environment:
+      MINIO_ROOT_USER: minioadmin
+      MINIO_ROOT_PASSWORD: minioadmin
+    ports:
+      - "${MINIO_PORT:-9000}:9000"
+      - "${MINIO_CONSOLE_PORT:-9001}:9001"
+    volumes:
+      - minio-data:/data
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://127.0.0.1:9000/minio/health/live"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+    restart: on-failure
+
   # TLC Dashboard
   dashboard:
     image: node:20-alpine
@@ -97,3 +128,4 @@ services:
 
 volumes:
   postgres-data:
+  minio-data:

package/help.md

@@ -76,14 +76,22 @@ Launches the visual dashboard. Detects where you are, shows what's next.
 
 | Command | What It Does |
 |---------|--------------|
-| `/tlc:docs` | Generate project docs (API, architecture, onboarding) |
+| `/tlc:docs` | Generate API docs (OpenAPI, MCP, examples) |
+| `/tlc:team-docs` | Generate team workflow, role guides, onboarding |
 
 ### Multi-Tool & Deployment
 
 | Command | What It Does |
 |---------|--------------|
-| `/tlc:export` | Export rules for Cursor, Copilot, Continue, Cody |
-| `/tlc:deploy` | VPS deployment with branch previews |
+| `/tlc:export` | Export TLC rules for AI tools (Cursor, Copilot, Cody, etc.) |
+| `/tlc:export --list` | Show all supported AI tools |
+| `/tlc:export --detect` | Detect which AI tool is running |
+| `/tlc:deploy` | Show deployment status |
+| `/tlc:deploy start <branch>` | Deploy branch to VPS |
+| `/tlc:deploy stop <branch>` | Stop branch deployment |
+| `/tlc:deploy logs <branch>` | View deployment logs |
+| `/tlc:deploy list` | List all active deployments |
+| `/tlc:deploy setup` | Show setup instructions |
 
 ---
 
@@ -140,6 +148,17 @@ Lives in `.claude/commands/tlc/`
 
 ---
 
+## Bash Permissions
+
+On first run, TLC offers to set up pre-approved bash commands. This avoids confirmation prompts for:
+- Test runs (`npm test`, `vitest`, `pytest`, etc.)
+- Git operations (except `push` - always asks)
+- Build commands (`npm run build`, `tsc`, etc.)
+
+Settings stored in `.claude/settings.json`. One-time setup per project.
+
+---
+
 ## Agents
 
 TLC includes specialized AI agents that handle research, planning, execution, and verification. Most are invoked automatically by commands.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tlc-claude-code",
-  "version": "0.9.6",
+  "version": "0.9.8",
   "description": "TLC - Test Led Coding for Claude Code",
   "bin": {
     "tlc": "./bin/tlc.js",
@@ -10,7 +10,12 @@
     "bin/",
     "dashboard/dist/",
     "dashboard/package.json",
-    "server/",
+    "server/index.js",
+    "server/lib/",
+    "server/dashboard/",
+    "server/package.json",
+    "server/package-lock.json",
+    "server/setup.sh",
     "docker-compose.dev.yml",
     "start-dev.ps1",
     "start-dev.sh",

package/server/lib/auth-flow-docs.js

@@ -0,0 +1,375 @@
+/**
+ * Auth Flow Documentation Module
+ * Generates documentation for authentication flows
+ */
+
+/**
+ * Common auth flow patterns
+ */
+const AUTH_PATTERNS = {
+  jwt: {
+    name: 'JWT Bearer Token',
+    type: 'http',
+    scheme: 'bearer',
+    bearerFormat: 'JWT',
+    description: 'JWT token obtained from login endpoint',
+    flow: [
+      'POST /auth/login with credentials',
+      'Receive { token: "eyJ..." }',
+      'Include header: Authorization: Bearer <token>',
+      'Token expires after configured TTL',
+    ],
+  },
+  apiKey: {
+    name: 'API Key',
+    type: 'apiKey',
+    in: 'header',
+    name: 'X-API-Key',
+    description: 'API key for service-to-service authentication',
+    flow: [
+      'Obtain API key from dashboard',
+      'Include header: X-API-Key: <key>',
+      'Key has configured permissions',
+    ],
+  },
+  basic: {
+    name: 'HTTP Basic Auth',
+    type: 'http',
+    scheme: 'basic',
+    description: 'Username and password in Authorization header',
+    flow: [
+      'Base64 encode "username:password"',
+      'Include header: Authorization: Basic <encoded>',
+    ],
+  },
+  oauth2: {
+    name: 'OAuth 2.0',
+    type: 'oauth2',
+    description: 'OAuth 2.0 authorization flow',
+    flows: {
+      authorizationCode: {
+        authorizationUrl: '/oauth/authorize',
+        tokenUrl: '/oauth/token',
+        scopes: {},
+      },
+    },
+    flow: [
+      'Redirect to /oauth/authorize with client_id',
+      'User approves access',
+      'Receive authorization code',
+      'Exchange code for token at /oauth/token',
+      'Use token in Authorization header',
+    ],
+  },
+  session: {
+    name: 'Session Cookie',
+    type: 'apiKey',
+    in: 'cookie',
+    name: 'session',
+    description: 'Session-based authentication using cookies',
+    flow: [
+      'POST /auth/login with credentials',
+      'Receive Set-Cookie header',
+      'Browser automatically includes cookie in requests',
+      'Session expires after configured TTL',
+    ],
+  },
+};
+
+/**
+ * Detect auth patterns from code
+ * @param {string} content - File content
+ * @returns {Array} Detected auth patterns
+ */
+function detectAuthPatterns(content) {
+  const patterns = [];
+
+  // JWT patterns
+  if (content.includes('jwt') || content.includes('jsonwebtoken') ||
+      content.includes('Bearer') || content.includes('bearer')) {
+    patterns.push('jwt');
+  }
+
+  // Basic auth
+  if (content.includes('basic') && content.includes('auth')) {
+    patterns.push('basic');
+  }
+
+  // API key patterns
+  if (content.includes('api-key') || content.includes('apiKey') ||
+      content.includes('x-api-key') || content.includes('X-API-Key')) {
+    patterns.push('apiKey');
+  }
+
+  // OAuth patterns
+  if (content.includes('oauth') || content.includes('OAuth') ||
+      content.includes('authorization_code') || content.includes('authorizationUrl')) {
+    patterns.push('oauth2');
+  }
+
+  // Session patterns
+  if (content.includes('session') && (content.includes('cookie') || content.includes('express-session'))) {
+    patterns.push('session');
+  }
+
+  return [...new Set(patterns)];
+}
+
+/**
+ * Extract security requirements from route
+ * @param {Object} route - Route object
+ * @param {string} handlerContent - Handler code content
+ * @returns {Object} Security requirements
+ */
+function extractSecurityRequirements(route, handlerContent = '') {
+  const requirements = {
+    requiresAuth: false,
+    schemes: [],
+    scopes: [],
+    roles: [],
+  };
+
+  // Check for auth middleware patterns
+  const authMiddlewarePatterns = [
+    /auth(?:enticate)?(?:d)?/i,
+    /requireAuth/i,
+    /isAuthenticated/i,
+    /protect(?:ed)?/i,
+    /verifyToken/i,
+  ];
+
+  for (const pattern of authMiddlewarePatterns) {
+    if (pattern.test(handlerContent)) {
+      requirements.requiresAuth = true;
+      break;
+    }
+  }
+
+  // Extract roles
+  const rolePatterns = [
+    /role[s]?\s*[=:]\s*['"`]([^'"`]+)['"`]/gi,
+    /hasRole\(['"`]([^'"`]+)['"`]\)/gi,
+    /requireRole\(['"`]([^'"`]+)['"`]\)/gi,
+  ];
+
+  for (const pattern of rolePatterns) {
+    let match;
+    while ((match = pattern.exec(handlerContent)) !== null) {
+      requirements.roles.push(match[1]);
+    }
+  }
+
+  // Detect schemes
+  const detectedSchemes = detectAuthPatterns(handlerContent);
+  requirements.schemes = detectedSchemes;
+
+  if (detectedSchemes.length > 0) {
+    requirements.requiresAuth = true;
+  }
+
+  return requirements;
+}
+
+/**
+ * Generate OpenAPI security scheme
+ * @param {string} patternName - Auth pattern name
+ * @param {Object} customConfig - Custom configuration
+ * @returns {Object} OpenAPI security scheme
+ */
+function generateSecurityScheme(patternName, customConfig = {}) {
+  const basePattern = AUTH_PATTERNS[patternName];
+  if (!basePattern) {
+    return null;
+  }
+
+  const scheme = {
+    type: basePattern.type,
+    description: customConfig.description || basePattern.description,
+  };
+
+  switch (basePattern.type) {
+    case 'http':
+      scheme.scheme = customConfig.scheme || basePattern.scheme;
+      if (basePattern.bearerFormat) {
+        scheme.bearerFormat = customConfig.bearerFormat || basePattern.bearerFormat;
+      }
+      break;
+    case 'apiKey':
+      scheme.in = customConfig.in || basePattern.in;
+      scheme.name = customConfig.name || basePattern.name;
+      break;
+    case 'oauth2':
+      scheme.flows = customConfig.flows || basePattern.flows;
+      break;
+  }
+
+  return scheme;
+}
+
+/**
+ * Generate auth flow documentation
+ * @param {Array} detectedPatterns - Detected auth patterns
+ * @param {Object} options - Documentation options
+ * @returns {Object} Auth documentation
+ */
+function generateAuthDocs(detectedPatterns, options = {}) {
+  const docs = {
+    securitySchemes: {},
+    flows: [],
+    endpoints: {
+      login: null,
+      logout: null,
+      register: null,
+      refresh: null,
+      verify: null,
+    },
+  };
+
+  // Generate schemes for detected patterns
+  for (const pattern of detectedPatterns) {
+    const schemeName = pattern === 'jwt' ? 'bearerAuth' :
+                       pattern === 'apiKey' ? 'apiKeyAuth' :
+                       pattern === 'basic' ? 'basicAuth' :
+                       pattern === 'oauth2' ? 'oauth2' :
+                       pattern === 'session' ? 'sessionAuth' : pattern;
+
+    docs.securitySchemes[schemeName] = generateSecurityScheme(pattern, options[pattern]);
+
+    if (AUTH_PATTERNS[pattern]) {
+      docs.flows.push({
+        name: AUTH_PATTERNS[pattern].name,
+        scheme: schemeName,
+        steps: AUTH_PATTERNS[pattern].flow,
+      });
+    }
+  }
+
+  // Detect common auth endpoints
+  if (options.routes) {
+    for (const route of options.routes) {
+      const pathLower = route.path.toLowerCase();
+
+      if (pathLower.includes('login') && route.method === 'POST') {
+        docs.endpoints.login = route;
+      }
+      if (pathLower.includes('logout') && route.method === 'POST') {
+        docs.endpoints.logout = route;
+      }
+      if (pathLower.includes('register') && route.method === 'POST') {
+        docs.endpoints.register = route;
+      }
+      if (pathLower.includes('refresh') && route.method === 'POST') {
+        docs.endpoints.refresh = route;
+      }
+      if ((pathLower.includes('verify') || pathLower.includes('me')) && route.method === 'GET') {
+        docs.endpoints.verify = route;
+      }
+    }
+  }
+
+  return docs;
+}
+
+/**
+ * Format auth flow for display
+ * @param {Object} flow - Auth flow object
+ * @returns {string} Formatted flow
+ */
+function formatAuthFlow(flow) {
+  const lines = [
+    `## ${flow.name}`,
+    '',
+    'Steps:',
+    ...flow.steps.map((step, i) => `${i + 1}. ${step}`),
+    '',
+  ];
+
+  return lines.join('\n');
+}
+
+/**
+ * Generate auth documentation markdown
+ * @param {Object} authDocs - Auth documentation object
+ * @returns {string} Markdown documentation
+ */
+function generateAuthMarkdown(authDocs) {
+  const sections = [];
+
+  sections.push('# Authentication');
+  sections.push('');
+
+  // Security schemes
+  if (Object.keys(authDocs.securitySchemes).length > 0) {
+    sections.push('## Security Schemes');
+    sections.push('');
+
+    for (const [name, scheme] of Object.entries(authDocs.securitySchemes)) {
+      sections.push(`### ${name}`);
+      sections.push('');
+      sections.push(`- **Type:** ${scheme.type}`);
+      if (scheme.scheme) {
+        sections.push(`- **Scheme:** ${scheme.scheme}`);
+      }
+      if (scheme.bearerFormat) {
+        sections.push(`- **Format:** ${scheme.bearerFormat}`);
+      }
+      if (scheme.description) {
+        sections.push(`- **Description:** ${scheme.description}`);
+      }
+      sections.push('');
+    }
+  }
+
+  // Auth flows
+  if (authDocs.flows.length > 0) {
+    sections.push('## Authentication Flows');
+    sections.push('');
+
+    for (const flow of authDocs.flows) {
+      sections.push(formatAuthFlow(flow));
+    }
+  }
+
+  // Auth endpoints
+  const hasEndpoints = Object.values(authDocs.endpoints).some(e => e !== null);
+  if (hasEndpoints) {
+    sections.push('## Auth Endpoints');
+    sections.push('');
+
+    for (const [name, endpoint] of Object.entries(authDocs.endpoints)) {
+      if (endpoint) {
+        sections.push(`- **${name}:** \`${endpoint.method} ${endpoint.path}\``);
+      }
+    }
+    sections.push('');
+  }
+
+  return sections.join('\n');
+}
+
+/**
+ * Create auth flow documentation generator
+ * @param {Object} options - Generator options
+ * @returns {Object} Generator instance
+ */
+function createAuthDocsGenerator(options = {}) {
+  return {
+    detectPatterns: detectAuthPatterns,
+    extractRequirements: extractSecurityRequirements,
+    generateScheme: generateSecurityScheme,
+    generateDocs: (patterns, opts) => generateAuthDocs(patterns, { ...options, ...opts }),
+    toMarkdown: generateAuthMarkdown,
+    formatFlow: formatAuthFlow,
+  };
+}
+
+module.exports = {
+  AUTH_PATTERNS,
+  detectAuthPatterns,
+  extractSecurityRequirements,
+  generateSecurityScheme,
+  generateAuthDocs,
+  formatAuthFlow,
+  generateAuthMarkdown,
+  createAuthDocsGenerator,
+};