commandmate 0.1.5 → 0.1.6

package/dist/server/src/lib/env.js

@@ -0,0 +1,179 @@
+"use strict";
+/**
+ * Environment variable configuration and validation
+ * Provides type-safe access to environment variables
+ *
+ * Issue #76: Environment variable fallback support
+ * Supports both new (CM_*) and legacy (MCBD_*) environment variable names
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENV_MAPPING = void 0;
+exports.resetWarnedKeys = resetWarnedKeys;
+exports.getEnvWithFallback = getEnvWithFallback;
+exports.getEnvByKey = getEnvByKey;
+exports.getLogConfig = getLogConfig;
+exports.getEnv = getEnv;
+exports.validateEnv = validateEnv;
+exports.isAuthRequired = isAuthRequired;
+const path_1 = __importDefault(require("path"));
+// ============================================================
+// Environment Variable Mapping (for fallback support)
+// Issue #76: CommandMate rename - Phase 1
+// ============================================================
+/**
+ * Environment variable mapping definition
+ * New name -> Old name mapping for fallback support
+ */
+exports.ENV_MAPPING = {
+    CM_ROOT_DIR: 'MCBD_ROOT_DIR',
+    CM_PORT: 'MCBD_PORT',
+    CM_BIND: 'MCBD_BIND',
+    CM_AUTH_TOKEN: 'MCBD_AUTH_TOKEN',
+    CM_LOG_LEVEL: 'MCBD_LOG_LEVEL',
+    CM_LOG_FORMAT: 'MCBD_LOG_FORMAT',
+    CM_LOG_DIR: 'MCBD_LOG_DIR',
+    CM_DB_PATH: 'MCBD_DB_PATH',
+};
+/**
+ * Set to track warned keys and prevent duplicate warnings
+ * Module-scoped to persist across function calls
+ */
+const warnedKeys = new Set();
+/**
+ * Reset warned keys (for testing purposes)
+ */
+function resetWarnedKeys() {
+    warnedKeys.clear();
+}
+/**
+ * Get environment variable with fallback support
+ *
+ * @param newKey - New environment variable name (CM_*)
+ * @param oldKey - Old environment variable name (MCBD_*)
+ * @returns Environment variable value (undefined if not set)
+ */
+function getEnvWithFallback(newKey, oldKey) {
+    const newValue = process.env[newKey];
+    if (newValue !== undefined) {
+        return newValue;
+    }
+    const oldValue = process.env[oldKey];
+    if (oldValue !== undefined) {
+        if (!warnedKeys.has(oldKey)) {
+            console.warn(`[DEPRECATED] ${oldKey} is deprecated, use ${newKey} instead`);
+            warnedKeys.add(oldKey);
+        }
+        return oldValue;
+    }
+    return undefined;
+}
+/**
+ * Get environment variable using ENV_MAPPING (type-safe version)
+ *
+ * @param key - New environment variable key (from ENV_MAPPING)
+ * @returns Environment variable value (undefined if not set)
+ */
+function getEnvByKey(key) {
+    return getEnvWithFallback(key, exports.ENV_MAPPING[key]);
+}
+/**
+ * Validate log level
+ */
+function isValidLogLevel(level) {
+    return level !== undefined && ['debug', 'info', 'warn', 'error'].includes(level);
+}
+/**
+ * Get log configuration (with fallback support)
+ *
+ * @returns Log configuration with level and format
+ *
+ * @example
+ * ```typescript
+ * const config = getLogConfig();
+ * console.log(config.level); // 'debug' in development, 'info' in production
+ * console.log(config.format); // 'text' or 'json'
+ * ```
+ */
+function getLogConfig() {
+    const levelEnv = getEnvByKey('CM_LOG_LEVEL')?.toLowerCase();
+    const formatEnv = getEnvByKey('CM_LOG_FORMAT')?.toLowerCase();
+    // Default: debug in development, info in production
+    const defaultLevel = process.env.NODE_ENV === 'production' ? 'info' : 'debug';
+    return {
+        level: isValidLogLevel(levelEnv) ? levelEnv : defaultLevel,
+        format: formatEnv === 'json' ? 'json' : 'text',
+    };
+}
+/**
+ * Get and validate environment variables (with fallback support)
+ *
+ * @throws {Error} If required variables are missing or invalid
+ * @returns Validated environment configuration
+ *
+ * @example
+ * ```typescript
+ * const env = getEnv();
+ * console.log(`Root directory: ${env.CM_ROOT_DIR}`);
+ * ```
+ */
+function getEnv() {
+    // Get raw values with defaults (using fallback support)
+    const rootDir = getEnvByKey('CM_ROOT_DIR') || process.cwd();
+    const port = parseInt(getEnvByKey('CM_PORT') || '3000', 10);
+    const bind = getEnvByKey('CM_BIND') || '127.0.0.1';
+    const authToken = getEnvByKey('CM_AUTH_TOKEN');
+    const databasePath = getEnvByKey('CM_DB_PATH')
+        || process.env.DATABASE_PATH
+        || path_1.default.join(process.cwd(), 'data', 'cm.db');
+    // Validate values
+    if (!rootDir) {
+        throw new Error('CM_ROOT_DIR (or MCBD_ROOT_DIR) is required');
+    }
+    if (isNaN(port) || port < 1 || port > 65535) {
+        throw new Error(`Invalid CM_PORT: ${getEnvByKey('CM_PORT')}. Must be between 1 and 65535.`);
+    }
+    if (bind !== '127.0.0.1' && bind !== '0.0.0.0' && bind !== 'localhost') {
+        throw new Error(`Invalid CM_BIND: ${bind}. Must be '127.0.0.1', '0.0.0.0', or 'localhost'.`);
+    }
+    // Require auth token for public binding
+    if (bind === '0.0.0.0' && !authToken) {
+        throw new Error('CM_AUTH_TOKEN (or MCBD_AUTH_TOKEN) is required when CM_BIND=0.0.0.0');
+    }
+    return {
+        CM_ROOT_DIR: path_1.default.resolve(rootDir),
+        CM_PORT: port,
+        CM_BIND: bind,
+        CM_AUTH_TOKEN: authToken,
+        CM_DB_PATH: path_1.default.resolve(databasePath),
+    };
+}
+/**
+ * Validate environment variables without throwing
+ *
+ * @returns Validation result with errors if any
+ */
+function validateEnv() {
+    const errors = [];
+    try {
+        getEnv();
+        return { valid: true, errors: [] };
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            errors.push(error.message);
+        }
+        return { valid: false, errors };
+    }
+}
+/**
+ * Check if authentication is required based on bind address
+ *
+ * @returns True if authentication is required
+ */
+function isAuthRequired() {
+    const env = getEnv();
+    return env.CM_BIND === '0.0.0.0';
+}

package/dist/server/src/lib/log-manager.js

@@ -0,0 +1,234 @@
+"use strict";
+/**
+ * Log file management for Claude output
+ * Generates and manages Markdown log files from Claude's responses
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLogFilePath = getLogFilePath;
+exports.createLog = createLog;
+exports.appendToLog = appendToLog;
+exports.readLog = readLog;
+exports.listLogs = listLogs;
+exports.cleanupOldLogs = cleanupOldLogs;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const date_fns_1 = require("date-fns");
+const env_1 = require("./env");
+/**
+ * Log directory configuration (with fallback support - Issue #76)
+ */
+const LOG_DIR = (0, env_1.getEnvByKey)('CM_LOG_DIR') || path_1.default.join(process.cwd(), 'data', 'logs');
+/**
+ * Get log directory for a CLI tool
+ *
+ * @param cliToolId - CLI tool ID (claude, codex, gemini)
+ * @returns Log directory path
+ */
+function getCliToolLogDir(cliToolId = 'claude') {
+    return path_1.default.join(LOG_DIR, cliToolId);
+}
+/**
+ * Ensure log directory exists
+ *
+ * @param cliToolId - CLI tool ID (optional, defaults to 'claude')
+ */
+async function ensureLogDirectory(cliToolId = 'claude') {
+    const logDir = getCliToolLogDir(cliToolId);
+    try {
+        await promises_1.default.access(logDir);
+    }
+    catch {
+        await promises_1.default.mkdir(logDir, { recursive: true });
+    }
+}
+/**
+ * Get log file path for a worktree
+ *
+ * @param worktreeId - Worktree ID
+ * @param cliToolId - CLI tool ID (claude, codex, gemini)
+ * @returns Log file path
+ *
+ * @example
+ * ```typescript
+ * getLogFilePath('feature-foo', 'claude')
+ * // => '/path/to/data/logs/claude/feature-foo-2025-01-20.md'
+ * ```
+ */
+function getLogFilePath(worktreeId, cliToolId = 'claude') {
+    const date = (0, date_fns_1.format)(new Date(), 'yyyy-MM-dd');
+    const filename = `${worktreeId}-${date}.md`;
+    const logDir = getCliToolLogDir(cliToolId);
+    return path_1.default.join(logDir, filename);
+}
+/**
+ * Create a Markdown log file for a conversation
+ *
+ * @param worktreeId - Worktree ID
+ * @param userMessage - User's message
+ * @param claudeResponse - Claude's response
+ * @param cliToolId - CLI tool ID (claude, codex, gemini)
+ * @returns Path to the created log file
+ *
+ * @example
+ * ```typescript
+ * const logPath = await createLog(
+ *   'feature-foo',
+ *   'Explain this code',
+ *   'This code implements...',
+ *   'claude'
+ * );
+ * ```
+ */
+async function createLog(worktreeId, userMessage, claudeResponse, cliToolId = 'claude') {
+    await ensureLogDirectory(cliToolId);
+    const logPath = getLogFilePath(worktreeId, cliToolId);
+    const timestamp = (0, date_fns_1.format)(new Date(), 'yyyy-MM-dd HH:mm:ss');
+    // Check if log file already exists
+    let logContent = '';
+    try {
+        logContent = await promises_1.default.readFile(logPath, 'utf-8');
+    }
+    catch {
+        // File doesn't exist, create header
+        const toolName = cliToolId === 'claude' ? 'Claude Code' : cliToolId === 'codex' ? 'Codex CLI' : 'Gemini CLI';
+        logContent = `# ${toolName} Conversation Log: ${worktreeId}\n\n`;
+        logContent += `Created: ${timestamp}\n\n`;
+        logContent += `---\n\n`;
+    }
+    // Append new conversation
+    logContent += `## Conversation at ${timestamp}\n\n`;
+    logContent += `### User\n\n`;
+    logContent += `${userMessage}\n\n`;
+    logContent += `### ${cliToolId === 'claude' ? 'Claude' : cliToolId === 'codex' ? 'Codex' : 'Gemini'}\n\n`;
+    logContent += `${claudeResponse}\n\n`;
+    logContent += `---\n\n`;
+    await promises_1.default.writeFile(logPath, logContent, 'utf-8');
+    return logPath;
+}
+/**
+ * Append to existing log file
+ *
+ * @param worktreeId - Worktree ID
+ * @param content - Content to append
+ * @param cliToolId - CLI tool ID (claude, codex, gemini)
+ *
+ * @example
+ * ```typescript
+ * await appendToLog('feature-foo', 'Additional notes...', 'claude');
+ * ```
+ */
+async function appendToLog(worktreeId, content, cliToolId = 'claude') {
+    await ensureLogDirectory(cliToolId);
+    const logPath = getLogFilePath(worktreeId, cliToolId);
+    const timestamp = (0, date_fns_1.format)(new Date(), 'yyyy-MM-dd HH:mm:ss');
+    let logContent = '';
+    try {
+        logContent = await promises_1.default.readFile(logPath, 'utf-8');
+    }
+    catch {
+        // File doesn't exist, create header
+        const toolName = cliToolId === 'claude' ? 'Claude Code' : cliToolId === 'codex' ? 'Codex CLI' : 'Gemini CLI';
+        logContent = `# ${toolName} Conversation Log: ${worktreeId}\n\n`;
+        logContent += `Created: ${timestamp}\n\n`;
+        logContent += `---\n\n`;
+    }
+    logContent += `${content}\n\n`;
+    await promises_1.default.writeFile(logPath, logContent, 'utf-8');
+}
+/**
+ * Read log file content
+ *
+ * @param worktreeId - Worktree ID
+ * @param cliToolId - CLI tool ID (claude, codex, gemini)
+ * @returns Log file content, or null if file doesn't exist
+ *
+ * @example
+ * ```typescript
+ * const log = await readLog('feature-foo', 'claude');
+ * if (log) {
+ *   console.log(log);
+ * }
+ * ```
+ */
+async function readLog(worktreeId, cliToolId = 'claude') {
+    const logPath = getLogFilePath(worktreeId, cliToolId);
+    try {
+        return await promises_1.default.readFile(logPath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * List all log files for a worktree
+ *
+ * @param worktreeId - Worktree ID
+ * @param cliToolId - CLI tool ID (claude, codex, gemini), or 'all' for all tools
+ * @returns Array of log file paths
+ *
+ * @example
+ * ```typescript
+ * const logs = await listLogs('feature-foo', 'claude');
+ * // => ['/path/to/logs/claude/feature-foo-2025-01-20.md', '/path/to/logs/claude/feature-foo-2025-01-19.md']
+ * ```
+ */
+async function listLogs(worktreeId, cliToolId = 'all') {
+    const toolIds = cliToolId === 'all' ? ['claude', 'codex', 'gemini'] : [cliToolId];
+    const allLogFiles = [];
+    for (const toolId of toolIds) {
+        await ensureLogDirectory(toolId);
+        const logDir = getCliToolLogDir(toolId);
+        try {
+            const files = await promises_1.default.readdir(logDir);
+            const logFiles = files
+                .filter((file) => file.startsWith(`${worktreeId}-`) && file.endsWith('.md'))
+                .map((file) => path_1.default.join(logDir, file));
+            allLogFiles.push(...logFiles);
+        }
+        catch {
+            // Directory doesn't exist or is not accessible, skip
+        }
+    }
+    return allLogFiles.sort().reverse(); // Most recent first
+}
+/**
+ * Delete old log files (older than specified days)
+ *
+ * @param days - Number of days to keep
+ *
+ * @example
+ * ```typescript
+ * // Delete logs older than 30 days
+ * await cleanupOldLogs(30);
+ * ```
+ */
+async function cleanupOldLogs(days = 30) {
+    const toolIds = ['claude', 'codex', 'gemini'];
+    let totalDeletedCount = 0;
+    const now = new Date();
+    const cutoffDate = new Date(now.getTime() - days * 24 * 60 * 60 * 1000);
+    for (const toolId of toolIds) {
+        await ensureLogDirectory(toolId);
+        const logDir = getCliToolLogDir(toolId);
+        try {
+            const files = await promises_1.default.readdir(logDir);
+            for (const file of files) {
+                if (!file.endsWith('.md'))
+                    continue;
+                const filePath = path_1.default.join(logDir, file);
+                const stats = await promises_1.default.stat(filePath);
+                if (stats.mtime < cutoffDate) {
+                    await promises_1.default.unlink(filePath);
+                    totalDeletedCount++;
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Error cleaning up old logs for ${toolId}:`, error);
+        }
+    }
+    return totalDeletedCount;
+}

package/dist/server/src/lib/logger.js

@@ -0,0 +1,232 @@
+"use strict";
+/**
+ * Structured logging utility for CommandMate
+ *
+ * Issue #41: Structured logging + log level control
+ *
+ * Features:
+ * - [MF-1] Sensitive data filtering (sanitize)
+ * - [MF-2] Server/Client log separation
+ * - [SF-2] Request ID generation
+ *
+ * @example
+ * ```typescript
+ * const logger = createLogger('prompt-detector');
+ * logger.debug('detectPrompt:start', { outputLength: 1500 });
+ *
+ * const log = logger.withContext({ worktreeId: 'wt-1', requestId: generateRequestId() });
+ * log.info('action:complete', { result: 'success' });
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRequestId = generateRequestId;
+exports.createLogger = createLogger;
+const env_1 = require("./env");
+// ============================================================
+// [MF-1] Sensitive Data Filtering
+// ============================================================
+/**
+ * Sensitive data patterns
+ */
+const SENSITIVE_PATTERNS = [
+    // Bearer token
+    { pattern: /Bearer\s+[A-Za-z0-9\-._~+/]+=*/gi, replacement: 'Bearer [REDACTED]' },
+    // Password related
+    { pattern: /(password|passwd|pwd)[=:]\s*\S+/gi, replacement: '$1=[REDACTED]' },
+    // Token/secret related
+    { pattern: /(token|secret|api_key|apikey|auth)[=:]\s*\S+/gi, replacement: '$1=[REDACTED]' },
+    // CM_AUTH_TOKEN (new name - Issue #76)
+    { pattern: /CM_AUTH_TOKEN=\S+/gi, replacement: 'CM_AUTH_TOKEN=[REDACTED]' },
+    // MCBD_AUTH_TOKEN (legacy name)
+    { pattern: /MCBD_AUTH_TOKEN=\S+/gi, replacement: 'MCBD_AUTH_TOKEN=[REDACTED]' },
+    // Authorization header
+    { pattern: /Authorization:\s*\S+/gi, replacement: 'Authorization: [REDACTED]' },
+    // SSH key
+    { pattern: /-----BEGIN\s+\w+\s+PRIVATE\s+KEY-----[\s\S]*?-----END\s+\w+\s+PRIVATE\s+KEY-----/g, replacement: '[SSH_KEY_REDACTED]' },
+];
+/**
+ * Sensitive key name patterns
+ */
+const SENSITIVE_KEY_PATTERN = /password|secret|token|key|auth/i;
+/**
+ * Sanitize value (mask sensitive data)
+ */
+function sanitize(value) {
+    if (typeof value === 'string') {
+        let sanitized = value;
+        for (const { pattern, replacement } of SENSITIVE_PATTERNS) {
+            sanitized = sanitized.replace(pattern, replacement);
+        }
+        return sanitized;
+    }
+    if (typeof value === 'object' && value !== null) {
+        if (Array.isArray(value)) {
+            return value.map(sanitize);
+        }
+        const result = {};
+        for (const [k, v] of Object.entries(value)) {
+            // Mask if key name is sensitive
+            if (SENSITIVE_KEY_PATTERN.test(k)) {
+                result[k] = '[REDACTED]';
+            }
+            else {
+                result[k] = sanitize(v);
+            }
+        }
+        return result;
+    }
+    return value;
+}
+// ============================================================
+// [MF-2] Server/Client Log Separation
+// ============================================================
+/**
+ * Check if running on server side
+ */
+function isServer() {
+    return typeof window === 'undefined';
+}
+/**
+ * Check if should log on client side
+ * Only output in development environment
+ */
+function shouldLogOnClient() {
+    return process.env.NODE_ENV === 'development';
+}
+// ============================================================
+// Log Level Control
+// ============================================================
+const LOG_LEVELS = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+};
+/**
+ * Get current log level
+ * [SF-1] Get from env.ts
+ */
+function getCurrentLogLevel() {
+    const config = (0, env_1.getLogConfig)();
+    return config.level;
+}
+/**
+ * Get log output format
+ * [SF-1] Get from env.ts
+ */
+function getLogFormat() {
+    const config = (0, env_1.getLogConfig)();
+    return config.format;
+}
+// ============================================================
+// Log Output
+// ============================================================
+/**
+ * Format log entry
+ */
+function formatLogEntry(entry) {
+    if (getLogFormat() === 'json') {
+        return JSON.stringify(entry);
+    }
+    // Text format
+    const { timestamp, level, module, action, data, worktreeId, cliToolId, requestId } = entry;
+    const contextParts = [worktreeId, cliToolId].filter(Boolean);
+    const contextStr = contextParts.length > 0 ? ` [${contextParts.join(':')}]` : '';
+    const requestIdStr = requestId ? ` (${requestId.slice(0, 8)})` : '';
+    const dataStr = data ? ` ${JSON.stringify(data)}` : '';
+    return `[${timestamp}] [${level.toUpperCase()}] [${module}]${contextStr}${requestIdStr} ${action}${dataStr}`;
+}
+/**
+ * Execute log output
+ */
+function log(level, module, action, data, context) {
+    const currentLevel = getCurrentLogLevel();
+    if (LOG_LEVELS[level] < LOG_LEVELS[currentLevel]) {
+        return; // Do not output if below threshold
+    }
+    // [MF-2] Only output on client side in development environment
+    if (!isServer() && !shouldLogOnClient()) {
+        return;
+    }
+    // [MF-1] Sanitize data
+    const sanitizedData = data ? sanitize(data) : undefined;
+    const entry = {
+        level,
+        module,
+        action,
+        timestamp: new Date().toISOString(),
+        ...context,
+        ...(sanitizedData && { data: sanitizedData }),
+    };
+    const formatted = formatLogEntry(entry);
+    // Server side: structured log, Client side: console group
+    if (isServer()) {
+        switch (level) {
+            case 'error':
+                console.error(formatted);
+                break;
+            case 'warn':
+                console.warn(formatted);
+                break;
+            default:
+                console.log(formatted);
+        }
+    }
+    else {
+        // Client side (development only)
+        const consoleMethod = level === 'error' ? 'error' : level === 'warn' ? 'warn' : 'log';
+        console[consoleMethod](`[${module}] ${action}`, sanitizedData || '');
+    }
+}
+// ============================================================
+// [SF-2] Request ID Generation
+// ============================================================
+/**
+ * Generate request ID
+ * UUID v4 format
+ */
+function generateRequestId() {
+    // crypto.randomUUID() is available in Node.js 19+ and modern browsers
+    // Provide fallback implementation
+    if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+        return crypto.randomUUID();
+    }
+    // Fallback: simple random ID
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+// ============================================================
+// Logger Factory
+// ============================================================
+/**
+ * Create module-specific logger
+ *
+ * @param module - Module name (e.g., 'prompt-detector', 'cli-session')
+ * @returns Logger instance
+ *
+ * @example
+ * ```typescript
+ * const logger = createLogger('api-worktrees');
+ *
+ * // Basic usage
+ * logger.info('GET:start');
+ * logger.debug('statusCheck', { worktreeId: 'wt-1' });
+ *
+ * // With context
+ * const log = logger.withContext({ worktreeId: 'wt-1', requestId: generateRequestId() });
+ * log.info('action:complete');
+ * ```
+ */
+function createLogger(module) {
+    const createLoggerWithContext = (context) => ({
+        debug: (action, data) => log('debug', module, action, data, context),
+        info: (action, data) => log('info', module, action, data, context),
+        warn: (action, data) => log('warn', module, action, data, context),
+        error: (action, data) => log('error', module, action, data, context),
+        withContext: (newContext) => createLoggerWithContext({ ...context, ...newContext }),
+    });
+    return createLoggerWithContext();
+}