commandmate 0.1.0 → 0.1.6

package/dist/server/src/lib/ws-server.js

@@ -0,0 +1,323 @@
+"use strict";
+/**
+ * WebSocket Server for Real-time Communication
+ * Manages WebSocket connections and room-based message broadcasting
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupWebSocket = setupWebSocket;
+exports.broadcast = broadcast;
+exports.broadcastMessage = broadcastMessage;
+exports.cleanupRooms = cleanupRooms;
+exports.closeWebSocket = closeWebSocket;
+const ws_1 = require("ws");
+// Global state
+let wss = null;
+const clients = new Map();
+const rooms = new Map();
+/**
+ * Setup WebSocket server on HTTP server
+ *
+ * @param server - HTTP server instance
+ *
+ * @example
+ * ```typescript
+ * const server = createServer();
+ * setupWebSocket(server);
+ * server.listen(3000);
+ * ```
+ */
+function setupWebSocket(server) {
+    wss = new ws_1.WebSocketServer({ server });
+    // Handle WebSocket server errors (e.g., invalid frames from clients)
+    wss.on('error', (error) => {
+        console.error('[WS Server] Error:', error.message);
+    });
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    wss.on('connection', (ws, req) => {
+        // Connection logging removed to reduce noise
+        // Initialize client info
+        const clientInfo = {
+            ws,
+            worktreeIds: new Set(),
+        };
+        clients.set(ws, clientInfo);
+        // Handle underlying socket errors (catches invalid frame errors earlier)
+        // Force destroy the socket on error to prevent further frame processing
+        const socket = ws._socket;
+        if (socket) {
+            socket.on('error', (err) => {
+                // Suppress common mobile browser disconnect errors
+                const isExpectedError = err.code === 'WS_ERR_INVALID_CLOSE_CODE' ||
+                    err.message?.includes('Invalid WebSocket frame') ||
+                    err.message?.includes('write after end') ||
+                    err.message?.includes('ECONNRESET') ||
+                    err.message?.includes('EPIPE');
+                if (!isExpectedError) {
+                    console.error('[WS Socket] Error:', err.message);
+                }
+                // Immediately destroy the socket to prevent further errors
+                try {
+                    if (socket.destroy)
+                        socket.destroy();
+                }
+                catch {
+                    // Socket may already be destroyed
+                }
+                handleDisconnect(ws);
+            });
+        }
+        // Handle messages
+        ws.on('message', (data) => {
+            try {
+                const message = JSON.parse(data.toString());
+                handleMessage(ws, message);
+            }
+            catch (parseError) {
+                console.error('Error parsing WebSocket message:', parseError);
+                // Don't close connection on parse error, just log it
+            }
+        });
+        // Handle disconnection - silently clean up
+        ws.on('close', () => {
+            handleDisconnect(ws);
+        });
+        // Handle errors (including invalid close codes from mobile browsers)
+        ws.on('error', (error) => {
+            // Suppress noisy errors from mobile browser disconnects
+            const isExpectedError = error.code === 'WS_ERR_INVALID_CLOSE_CODE' ||
+                error.message?.includes('Invalid WebSocket frame') ||
+                error.message?.includes('write after end');
+            if (!isExpectedError) {
+                console.error('[WS] WebSocket error:', error.message);
+            }
+            // Immediately terminate to prevent further errors
+            try {
+                ws.terminate();
+            }
+            catch {
+                // WebSocket may already be closed
+            }
+            handleDisconnect(ws);
+        });
+    });
+    console.log('WebSocket server initialized');
+}
+/**
+ * Handle incoming WebSocket message
+ */
+function handleMessage(ws, message) {
+    switch (message.type) {
+        case 'subscribe':
+            handleSubscribe(ws, message.worktreeId);
+            break;
+        case 'unsubscribe':
+            handleUnsubscribe(ws, message.worktreeId);
+            break;
+        case 'broadcast':
+            handleBroadcast(message.worktreeId, message.data);
+            break;
+        default:
+            console.warn('Unknown message type:', message);
+    }
+}
+/**
+ * Subscribe client to a worktree room
+ */
+function handleSubscribe(ws, worktreeId) {
+    const clientInfo = clients.get(ws);
+    if (!clientInfo) {
+        console.log(`[WS] handleSubscribe: clientInfo not found for worktreeId: ${worktreeId}`);
+        return;
+    }
+    // Add worktreeId to client's subscriptions
+    clientInfo.worktreeIds.add(worktreeId);
+    // Add client to room
+    if (!rooms.has(worktreeId)) {
+        rooms.set(worktreeId, new Set());
+    }
+    const room = rooms.get(worktreeId);
+    room.add(ws);
+    console.log(`Client subscribed to worktree: ${worktreeId}, room size: ${room.size}, ws readyState: ${ws.readyState}`);
+}
+/**
+ * Unsubscribe client from a worktree room
+ */
+function handleUnsubscribe(ws, worktreeId) {
+    const clientInfo = clients.get(ws);
+    if (!clientInfo)
+        return;
+    // Remove worktreeId from client's subscriptions
+    clientInfo.worktreeIds.delete(worktreeId);
+    // Remove client from room
+    const room = rooms.get(worktreeId);
+    if (room) {
+        room.delete(ws);
+        // Clean up empty rooms
+        if (room.size === 0) {
+            rooms.delete(worktreeId);
+        }
+    }
+    console.log(`Client unsubscribed from worktree: ${worktreeId}`);
+}
+/**
+ * Broadcast message to all clients in a worktree room
+ */
+function handleBroadcast(worktreeId, data) {
+    const room = rooms.get(worktreeId);
+    console.log(`[WS] handleBroadcast called for ${worktreeId}, room size: ${room?.size || 0}`);
+    if (!room) {
+        console.log(`[WS] No room found for ${worktreeId}`);
+        return;
+    }
+    if (room.size === 0) {
+        console.log(`[WS] Room for ${worktreeId} is empty`);
+        return;
+    }
+    try {
+        const message = JSON.stringify({
+            type: 'broadcast',
+            worktreeId,
+            data,
+        });
+        let successCount = 0;
+        let errorCount = 0;
+        room.forEach((client) => {
+            if (client.readyState === ws_1.WebSocket.OPEN) {
+                try {
+                    client.send(message);
+                    successCount++;
+                }
+                catch (sendError) {
+                    errorCount++;
+                    console.error(`Error sending WebSocket message to client:`, sendError);
+                }
+            }
+        });
+        console.log(`Broadcast to worktree ${worktreeId}: ${successCount}/${room.size} clients (${errorCount} errors)`);
+    }
+    catch (broadcastError) {
+        console.error(`Error broadcasting to worktree ${worktreeId}:`, broadcastError);
+        // Try to broadcast with sanitized data
+        try {
+            const sanitizedMessage = JSON.stringify({
+                type: 'broadcast',
+                worktreeId,
+                data: { error: 'Message encoding error' },
+            });
+            room.forEach((client) => {
+                if (client.readyState === ws_1.WebSocket.OPEN) {
+                    try {
+                        client.send(sanitizedMessage);
+                    }
+                    catch {
+                        // Silent fail for fallback
+                    }
+                }
+            });
+        }
+        catch (fallbackError) {
+            console.error('Failed to send fallback message:', fallbackError);
+        }
+    }
+}
+/**
+ * Handle client disconnection
+ */
+function handleDisconnect(ws) {
+    const clientInfo = clients.get(ws);
+    if (!clientInfo)
+        return;
+    // Remove client from all rooms
+    clientInfo.worktreeIds.forEach((worktreeId) => {
+        const room = rooms.get(worktreeId);
+        if (room) {
+            room.delete(ws);
+            // Clean up empty rooms
+            if (room.size === 0) {
+                rooms.delete(worktreeId);
+            }
+        }
+    });
+    // Remove client from clients map
+    clients.delete(ws);
+}
+/**
+ * Broadcast message to a specific worktree room (for API use)
+ *
+ * @param worktreeId - Worktree identifier
+ * @param data - Data to broadcast
+ *
+ * @example
+ * ```typescript
+ * broadcast('feature-foo', { type: 'message', content: 'New message' });
+ * ```
+ */
+function broadcast(worktreeId, data) {
+    handleBroadcast(worktreeId, data);
+}
+/**
+ * Broadcast message with type to a specific worktree room
+ *
+ * @param type - Message type
+ * @param data - Data to broadcast (should include worktreeId)
+ *
+ * @example
+ * ```typescript
+ * broadcastMessage('message', { worktreeId: 'feature-foo', message: {...} });
+ * ```
+ */
+function broadcastMessage(type, data) {
+    if (data.worktreeId) {
+        handleBroadcast(data.worktreeId, { type, ...data });
+    }
+    else {
+        console.warn('broadcastMessage called without worktreeId');
+    }
+}
+/**
+ * Clean up WebSocket rooms for deleted worktrees
+ * Removes rooms from the rooms map (clients will naturally disconnect or resubscribe)
+ *
+ * @param worktreeIds - Array of worktree IDs to clean up
+ *
+ * @example
+ * ```typescript
+ * cleanupRooms(['wt-1', 'wt-2', 'wt-3']);
+ * ```
+ */
+function cleanupRooms(worktreeIds) {
+    for (const worktreeId of worktreeIds) {
+        const room = rooms.get(worktreeId);
+        if (room) {
+            // Unsubscribe all clients from this room
+            room.forEach((ws) => {
+                const clientInfo = clients.get(ws);
+                if (clientInfo) {
+                    clientInfo.worktreeIds.delete(worktreeId);
+                }
+            });
+            // Delete the room
+            rooms.delete(worktreeId);
+            console.log(`[WS] Cleaned up room for worktree: ${worktreeId}`);
+        }
+    }
+}
+/**
+ * Close WebSocket server
+ * Used for testing and graceful shutdown
+ */
+function closeWebSocket() {
+    if (wss) {
+        // Close all client connections
+        clients.forEach((clientInfo) => {
+            clientInfo.ws.close();
+        });
+        // Clear state
+        clients.clear();
+        rooms.clear();
+        // Close server
+        wss.close();
+        wss = null;
+        console.log('WebSocket server closed');
+    }
+}

package/dist/server/src/types/clone.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * Clone URL Registration Types
+ * Issue #71: Clone URL registration feature
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCloneJobStatus = isCloneJobStatus;
+exports.isCloneError = isCloneError;
+exports.isValidationError = isValidationError;
+// Type guards
+/**
+ * Check if value is a valid CloneJobStatus
+ */
+function isCloneJobStatus(value) {
+    return (typeof value === 'string' &&
+        ['pending', 'running', 'completed', 'failed', 'cancelled'].includes(value));
+}
+/**
+ * Check if value is a valid CloneError
+ */
+function isCloneError(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const obj = value;
+    const validCategories = ['validation', 'network', 'auth', 'filesystem', 'git', 'system'];
+    return (typeof obj.category === 'string' &&
+        validCategories.includes(obj.category) &&
+        typeof obj.code === 'string' &&
+        typeof obj.message === 'string' &&
+        typeof obj.recoverable === 'boolean' &&
+        typeof obj.suggestedAction === 'string');
+}
+/**
+ * Check if error is a validation error
+ */
+function isValidationError(error) {
+    return error.category === 'validation';
+}

package/dist/server/src/types/conversation.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Conversation Pair Types
+ *
+ * Types for grouping user-assistant message pairs in the UI layer.
+ * These types are used to display conversation history with 1:1 correspondence
+ * between user inputs and assistant responses.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/src/types/external-apps.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Type definitions for external apps module
+ * Issue #42: Proxy routing for multiple frontend applications
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/src/types/infinite-messages.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * Type definitions for infinite message loading functionality
+ *
+ * Used by useInfiniteMessages hook and related components.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInfiniteMessagesError = createInfiniteMessagesError;
+/**
+ * Creates a structured InfiniteMessagesError from an unknown error
+ *
+ * @param options - Error creation options
+ * @returns Structured error object
+ */
+function createInfiniteMessagesError(options) {
+    const { error, defaultMessage = 'An error occurred' } = options;
+    // Handle TypeError (typically network errors)
+    if (error instanceof TypeError && error.message.includes('fetch')) {
+        return {
+            code: 'NETWORK_ERROR',
+            message: 'Network error occurred. Please check your connection.',
+            retryable: true,
+            originalError: error,
+        };
+    }
+    // Handle Response objects (server errors)
+    if (error instanceof Response) {
+        if (error.status >= 500) {
+            return {
+                code: 'SERVER_ERROR',
+                message: 'Server error occurred. Please try again later.',
+                retryable: true,
+            };
+        }
+        return {
+            code: 'UNKNOWN',
+            message: `Request failed with status ${error.status}`,
+            retryable: error.status !== 404,
+        };
+    }
+    // Handle SyntaxError (parse errors)
+    if (error instanceof SyntaxError) {
+        return {
+            code: 'PARSE_ERROR',
+            message: 'Failed to parse response. Please try again.',
+            retryable: true,
+            originalError: error,
+        };
+    }
+    // Handle generic Error objects
+    if (error instanceof Error) {
+        return {
+            code: 'UNKNOWN',
+            message: error.message || defaultMessage,
+            retryable: true,
+            originalError: error,
+        };
+    }
+    // Handle unknown error types
+    return {
+        code: 'UNKNOWN',
+        message: defaultMessage,
+        retryable: true,
+    };
+}

package/dist/server/src/types/markdown-editor.js

@@ -0,0 +1,94 @@
+"use strict";
+/**
+ * Type definitions for markdown editor feature
+ *
+ * @module types/markdown-editor
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_LAYOUT_STATE = exports.MAX_SPLIT_RATIO = exports.MIN_SPLIT_RATIO = exports.DEFAULT_SPLIT_RATIO = exports.FILE_SIZE_LIMITS = exports.PREVIEW_DEBOUNCE_MS = exports.LOCAL_STORAGE_KEY_MAXIMIZED = exports.LOCAL_STORAGE_KEY_SPLIT_RATIO = exports.LOCAL_STORAGE_KEY = exports.VIEW_MODE_STRATEGIES = void 0;
+exports.isValidSplitRatio = isValidSplitRatio;
+exports.isValidBoolean = isValidBoolean;
+/**
+ * View mode strategies lookup
+ */
+exports.VIEW_MODE_STRATEGIES = {
+    split: {
+        showEditor: true,
+        showPreview: true,
+        editorWidth: 'w-1/2',
+        previewWidth: 'w-1/2',
+    },
+    editor: {
+        showEditor: true,
+        showPreview: false,
+        editorWidth: 'w-full',
+        previewWidth: 'w-0',
+    },
+    preview: {
+        showEditor: false,
+        showPreview: true,
+        editorWidth: 'w-0',
+        previewWidth: 'w-full',
+    },
+};
+/**
+ * Local storage key for view mode persistence
+ */
+exports.LOCAL_STORAGE_KEY = 'commandmate:md-editor-view-mode';
+/**
+ * Local storage key for split ratio persistence
+ */
+exports.LOCAL_STORAGE_KEY_SPLIT_RATIO = 'commandmate:md-editor-split-ratio';
+/**
+ * Local storage key for maximized state persistence
+ */
+exports.LOCAL_STORAGE_KEY_MAXIMIZED = 'commandmate:md-editor-maximized';
+/**
+ * Default debounce delay for preview updates (in milliseconds)
+ */
+exports.PREVIEW_DEBOUNCE_MS = 300;
+/**
+ * File size thresholds
+ */
+exports.FILE_SIZE_LIMITS = {
+    /** Warning threshold (500KB) */
+    WARNING_THRESHOLD: 500 * 1024,
+    /** Maximum file size (1MB) */
+    MAX_SIZE: 1024 * 1024,
+};
+/**
+ * Default split ratio (50:50)
+ */
+exports.DEFAULT_SPLIT_RATIO = 0.5;
+/**
+ * Minimum split ratio (10%)
+ */
+exports.MIN_SPLIT_RATIO = 0.1;
+/**
+ * Maximum split ratio (90%)
+ */
+exports.MAX_SPLIT_RATIO = 0.9;
+/**
+ * Default editor layout state
+ */
+exports.DEFAULT_LAYOUT_STATE = {
+    viewMode: 'split',
+    isMaximized: false,
+    splitRatio: exports.DEFAULT_SPLIT_RATIO,
+};
+/**
+ * Validate split ratio value
+ * @param value - Value to validate
+ * @returns true if valid split ratio (0.1-0.9)
+ */
+function isValidSplitRatio(value) {
+    return typeof value === 'number' && value >= exports.MIN_SPLIT_RATIO && value <= exports.MAX_SPLIT_RATIO;
+}
+/**
+ * Validate boolean value from localStorage
+ * @param value - Value to validate
+ * @returns true if valid boolean
+ */
+function isValidBoolean(value) {
+    return typeof value === 'boolean';
+}

package/dist/server/src/types/models.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Data models for myCodeBranchDesk
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/src/types/sidebar.js

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * Sidebar Type Definitions
+ *
+ * Types for sidebar components and branch status display
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateHasUnread = calculateHasUnread;
+exports.toBranchItem = toBranchItem;
+/**
+ * Determine branch status from Worktree data
+ *
+ * Status priority:
+ * - waiting: Claude asked a yes/no prompt, waiting for user's answer (green dot)
+ * - running: Claude is actively processing user's request (spinner)
+ * - ready: Session running, waiting for user's new message (green dot)
+ * - idle: Session not running (gray dot)
+ */
+function determineBranchStatus(worktree) {
+    // Check CLI-specific status first
+    const claudeStatus = worktree.sessionStatusByCli?.claude;
+    if (claudeStatus) {
+        if (claudeStatus.isWaitingForResponse) {
+            return 'waiting';
+        }
+        if (claudeStatus.isProcessing) {
+            return 'running';
+        }
+        // Session running but not processing = ready (waiting for user to type new message)
+        if (claudeStatus.isRunning) {
+            return 'ready';
+        }
+    }
+    // Fall back to legacy status fields
+    if (worktree.isWaitingForResponse) {
+        return 'waiting';
+    }
+    if (worktree.isProcessing) {
+        return 'running';
+    }
+    // Session running but not processing = ready
+    if (worktree.isSessionRunning) {
+        return 'ready';
+    }
+    return 'idle';
+}
+/**
+ * Calculate whether a worktree has unread messages
+ *
+ * hasUnread is true when:
+ * - There is at least one assistant message (lastAssistantMessageAt exists)
+ * - AND the user has never viewed this worktree (lastViewedAt is null)
+ *   OR the last assistant message is newer than the last view
+ *
+ * @param worktree - Source worktree data
+ * @returns true if there are unread messages
+ */
+function calculateHasUnread(worktree) {
+    // No assistant messages = no unread
+    if (!worktree.lastAssistantMessageAt) {
+        return false;
+    }
+    // Never viewed but has assistant message = unread
+    if (!worktree.lastViewedAt) {
+        return true;
+    }
+    // Compare timestamps: unread if assistant message is newer than last view
+    return new Date(worktree.lastAssistantMessageAt) > new Date(worktree.lastViewedAt);
+}
+/**
+ * Convert Worktree to SidebarBranchItem for display
+ *
+ * @param worktree - Source worktree data
+ * @returns SidebarBranchItem for sidebar display
+ */
+function toBranchItem(worktree) {
+    const status = determineBranchStatus(worktree);
+    // Use new hasUnread logic based on lastAssistantMessageAt and lastViewedAt
+    const hasUnread = calculateHasUnread(worktree);
+    return {
+        id: worktree.id,
+        name: worktree.name,
+        repositoryName: worktree.repositoryName,
+        status,
+        hasUnread,
+        lastActivity: worktree.updatedAt,
+        description: worktree.description,
+    };
+}

package/dist/server/src/types/slash-commands.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * Slash Command Types
+ *
+ * Type definitions for slash commands loaded from .claude/commands/*.md
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMMAND_CATEGORIES = exports.CATEGORY_LABELS = void 0;
+/**
+ * Category labels for display
+ */
+exports.CATEGORY_LABELS = {
+    planning: 'Planning',
+    development: 'Development',
+    review: 'Review',
+    documentation: 'Documentation',
+    workflow: 'Workflow',
+    // Standard command category labels (Issue #56)
+    'standard-session': 'Standard (Session)',
+    'standard-config': 'Standard (Config)',
+    'standard-monitor': 'Standard (Monitor)',
+    'standard-git': 'Standard (Git)',
+    'standard-util': 'Standard (Utility)',
+};
+/**
+ * Command to category mapping
+ * Maps command names to their categories
+ */
+exports.COMMAND_CATEGORIES = {
+    // Planning commands
+    'work-plan': 'planning',
+    'issue-create': 'planning',
+    'issue-split': 'planning',
+    'design-policy': 'planning',
+    // Development commands
+    'tdd-impl': 'development',
+    'bug-fix': 'development',
+    'refactoring': 'development',
+    // Review commands
+    'architecture-review': 'review',
+    'acceptance-test': 'review',
+    // Documentation commands
+    'progress-report': 'documentation',
+    // Workflow commands
+    'create-pr': 'workflow',
+    'pm-auto-dev': 'workflow',
+};

package/dist/server/src/types/ui-actions.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * UI Action Type Definitions
+ *
+ * Defines all actions that can modify the WorktreeUIState
+ * Based on Issue #13 UX Improvement design specification (Section 16.3)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });