centaurus-cli 2.8.9 → 2.9.0

package/dist/cli-adapter.js

@@ -17,6 +17,8 @@ import { createPlanTool, markTaskCompleteTool, getCurrentPlan, clearPlan, approv
 import { webSearchTool, fetchUrlTool } from './tools/web-search.js';
 import { taskCompleteTool } from './tools/task-complete.js';
 import { readBinaryFileTool } from './tools/read-binary-file.js';
+import { createImageTool } from './tools/create-image.js';
+import { backgroundCommandTool } from './tools/background-command.js';
 import { apiClient } from './services/api-client.js';
 import { conversationManager } from './services/conversation-manager.js';
 import { aiServiceClient } from './services/ai-service-client.js';
@@ -89,6 +91,7 @@ export class CentaurusCLI {
     onShowBackgroundTaskPickerCallback;
     onShowBackgroundTaskCancelPickerCallback;
     onBackgroundTaskViewCallback;
+    onTokenCountUpdate; // Report actual AI context token count to UI
     constructor() {
         this.configManager = new ConfigManager();
         this.toolRegistry = new ToolRegistry();
@@ -174,6 +177,9 @@ export class CentaurusCLI {
     setOnConnectionStatusUpdate(callback) {
         this.onConnectionStatusUpdate = callback;
     }
+    setOnTokenCountUpdate(callback) {
+        this.onTokenCountUpdate = callback;
+    }
     async initializeMCP() {
         try {
             const mcpConfigManager = new MCPConfigManager();
@@ -248,9 +254,9 @@ export class CentaurusCLI {
             // This prevents caching issues when we update model configs
             this.configManager.set('model', selectedModel.id);
             this.configManager.set('modelName', selectedModel.name);
-            // Notify UI of model name change
+            // Notify UI of model name change and contextWindow
             if (this.onModelChange) {
-                this.onModelChange(selectedModel.name);
+                this.onModelChange(selectedModel.name, selectedModel.contextWindow);
             }
             const responseMessage = `Model changed to: ${selectedModel.name}`;
             // Send response back to UI
@@ -343,6 +349,8 @@ export class CentaurusCLI {
         this.toolRegistry.register(fetchUrlTool);
         this.toolRegistry.register(taskCompleteTool);
         this.toolRegistry.register(readBinaryFileTool);
+        this.toolRegistry.register(createImageTool);
+        this.toolRegistry.register(backgroundCommandTool);
         // Load configuration
         const config = this.configManager.load();
         // Enable backend sync if authenticated
@@ -404,47 +412,24 @@ Press Enter to continue...
     }
     /**
      * Start a new conversation in the backend
+     * @deprecated Backend conversation creation is no longer needed since messages are stored locally
+     * This function is kept as a no-op for compatibility
      */
     async ensureConversationStarted() {
-        if (this.conversationStarted || !apiClient.isAuthenticated()) {
-            return;
-        }
-        // Check if conversationManager already has a conversation (e.g., created by App.tsx for image upload)
-        // This prevents duplicate conversation creation
-        if (conversationManager.getCurrentConversationId()) {
-            this.conversationStarted = true;
-            return;
-        }
-        try {
-            const config = this.configManager.load();
-            const title = `Conversation ${new Date().toLocaleString()}`;
-            await conversationManager.startNewConversation(title, config.model || 'gemini-2.5-flash', 'google', // Always use Google provider now
-            this.cwd);
-            this.conversationStarted = true;
-        }
-        catch (error) {
-            // Silently continue without backend persistence
-        }
+        // No-op: Backend conversation creation has been disabled
+        // Conversations are now managed locally via local-chat-storage.ts
+        return;
     }
     /**
      * Save a message to the backend
+     * @deprecated Messages are now stored locally only via saveCurrentChat()
+     * This function is kept as a no-op for compatibility
      */
     async saveMessageToBackend(role, content) {
-        if (!apiClient.isAuthenticated()) {
-            return;
-        }
-        try {
-            await this.ensureConversationStarted();
-            await conversationManager.addMessage({
-                role,
-                content,
-                contentType: 'text',
-                metadata: {},
-            });
-        }
-        catch (error) {
-            // Silently continue without backend persistence
-        }
+        // No-op: Messages are stored locally only
+        // Backend message storage has been disabled to avoid "failed to fetch" errors
+        // All conversation history is persisted via local-chat-storage.ts
+        return;
     }
     getModel() {
         const config = this.configManager.load();
@@ -500,6 +485,27 @@ Press Enter to continue...
             this.conversationHistory.splice(lastAssistantWithToolCallsIndex);
         }
     }
+    /**
+     * Strip thinking blocks from ALL assistant messages in the conversation history.
+     *
+     * This is called at the START of a new user request to clear thinking from
+     * previous tasks. During the current agent loop, thinking is preserved for
+     * all turns to help the AI maintain reasoning context.
+     *
+     * Pattern:
+     * - New user request starts → strip ALL thinking from history
+     * - During agent loop (multi-turn tool execution) → keep ALL thinking
+     * - This allows AI to remember reasoning for current task but not old tasks
+     */
+    stripThinkingFromHistory() {
+        for (let i = 0; i < this.conversationHistory.length; i++) {
+            const msg = this.conversationHistory[i];
+            if (msg.role === 'assistant' && msg.thinking) {
+                // Remove thinking from the message in place
+                delete msg.thinking;
+            }
+        }
+    }
     async handleMessage(message) {
         // Handle command mode - execute commands directly
         if (this.commandMode) {
@@ -550,13 +556,17 @@ CRITICAL INSTRUCTIONS:
 DO NOT use write_to_file, edit_file, or execute_command until the plan is approved.`;
             userMessageContent = planModePrefix;
         }
+        // NEW USER REQUEST: Strip thinking from previous tasks
+        // This clears thinking from the previous agent loop but thinking will be
+        // preserved for all turns within the current agent loop
+        this.stripThinkingFromHistory();
         // Add user message to history
         this.conversationHistory.push({
             role: 'user',
             content: userMessageContent,
         });
-        // Save user message to backend (save original message for display, not the prefixed version)
-        await this.saveMessageToBackend('user', message);
+        // Messages are stored locally only - no backend persistence needed
+        // Local storage is handled by saveCurrentChat() which saves to ~/.centaurus/chats/
         // Start logging session and log user message
         conversationLogger.startSession();
         conversationLogger.logUserMessage(message);
@@ -606,7 +616,8 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
             let narrationAttempts = 0; // Track how many times AI narrated without executing
             let completionAttempts = 0; // Track how many times AI provided text summary without task_complete
             let thoughtStartTime = null; // Track when thinking started
-            let thoughtContent = ''; // Accumulate thought content
+            let thoughtContent = ''; // Accumulate thought content during streaming
+            let currentTurnThinking = ''; // Persist thinking for the current turn to attach to assistant message
             // ANTI-LOOP: Track duplicate tool calls to detect infinite loops
             const MAX_DUPLICATE_CALLS = 2; // Max times same operation allowed on same target
             const fileWriteTracker = new Map(); // Track writes per file
@@ -631,7 +642,28 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                 // DEBUG: Log message history state before AI call
                 const messageStats = {
                     totalMessages: messages.length,
-                    totalCharacters: messages.reduce((sum, m) => sum + (typeof m.content === 'string' ? m.content.length : 0), 0),
+                    totalCharacters: messages.reduce((sum, m) => {
+                        let len = typeof m.content === 'string' ? m.content.length : 0;
+                        // Include thinking content (internal reasoning)
+                        if (m.thinking) {
+                            len += m.thinking.length;
+                        }
+                        // Include tool calls (name + arguments)
+                        if (m.tool_calls) {
+                            m.tool_calls.forEach(tc => {
+                                len += tc.name.length;
+                                // Arguments are JSON stringified in the payload
+                                if (tc.arguments) {
+                                    len += JSON.stringify(tc.arguments).length;
+                                }
+                            });
+                        }
+                        // Include tool_call_id for tool messages
+                        if (m.role === 'tool' && m.tool_call_id) {
+                            len += m.tool_call_id.length;
+                        }
+                        return sum + len;
+                    }, 0),
                     byRole: {
                         system: messages.filter(m => m.role === 'system').length,
                         user: messages.filter(m => m.role === 'user').length,
@@ -647,6 +679,13 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                     quickLog(`[${new Date().toISOString()}] [CLI] Assistant messages with tool_calls: ${messageStats.assistantWithToolCalls}\n`);
                 }
                 catch (e) { }
+                // Report actual token count to UI (estimate: 1 token ≈ 4 chars)
+                // Include system prompt estimate (~14000 chars based on backend logs)
+                const SYSTEM_PROMPT_ESTIMATE = 14000; // Backend injects ~14K char system prompt
+                const estimatedTokens = Math.ceil((messageStats.totalCharacters + SYSTEM_PROMPT_ESTIMATE) / 4);
+                if (this.onTokenCountUpdate) {
+                    this.onTokenCountUpdate(estimatedTokens);
+                }
                 // Stream AI response from backend
                 // Backend will inject system prompt automatically with environment context
                 for await (const chunk of aiServiceClient.streamChat(selectedModel, messages, tools, environmentContext, mode, selectedModelThinkingConfig, this.currentAbortController.signal)) {
@@ -687,6 +726,8 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                             if (this.onThoughtCompleteCallback) {
                                 this.onThoughtCompleteCallback(thinkingDuration);
                             }
+                            // Capture thinking for this turn before clearing
+                            currentTurnThinking = thoughtContent;
                             thoughtStartTime = null;
                             thoughtContent = '';
                         }
@@ -719,6 +760,8 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                             if (this.onThoughtCompleteCallback) {
                                 this.onThoughtCompleteCallback(thinkingDuration);
                             }
+                            // Capture thinking for this turn before clearing
+                            currentTurnThinking = thoughtContent;
                             thoughtStartTime = null;
                             thoughtContent = '';
                         }
@@ -747,6 +790,8 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                             if (this.onThoughtCompleteCallback) {
                                 this.onThoughtCompleteCallback(thinkingDuration);
                             }
+                            // Capture thinking for this turn before clearing
+                            currentTurnThinking = thoughtContent;
                             thoughtStartTime = null;
                             thoughtContent = '';
                         }
@@ -845,11 +890,15 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                                                     this.onPlanModeChange(false);
                                                 }
                                                 // Add assistant message with plan tool call to history
-                                                this.conversationHistory.push({
+                                                const planAssistantMsg = {
                                                     role: 'assistant',
                                                     content: '',
                                                     tool_calls: [toolCall],
-                                                });
+                                                };
+                                                if (currentTurnThinking) {
+                                                    planAssistantMsg.thinking = currentTurnThinking;
+                                                }
+                                                this.conversationHistory.push(planAssistantMsg);
                                                 // Add plan approval response
                                                 this.conversationHistory.push({
                                                     role: 'tool',
@@ -885,11 +934,15 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                                         else {
                                             // No approval callback - add the tool result to history and wait for user response
                                             // This ensures the AI doesn't get stuck in a silent loop
-                                            this.conversationHistory.push({
+                                            const planAssistantMsg = {
                                                 role: 'assistant',
                                                 content: '',
                                                 tool_calls: [toolCall],
-                                            });
+                                            };
+                                            if (currentTurnThinking) {
+                                                planAssistantMsg.thinking = currentTurnThinking;
+                                            }
+                                            this.conversationHistory.push(planAssistantMsg);
                                             this.conversationHistory.push({
                                                 role: 'tool',
                                                 tool_call_id: toolCall.id,
@@ -909,11 +962,15 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                                         // Log error and add error result to history so AI knows
                                         logWarning(`Failed to parse plan: ${parseError?.message || parseError}`);
                                         // CRITICAL: Add tool result even on parse error to prevent silent loop
-                                        this.conversationHistory.push({
+                                        const errorAssistantMsg = {
                                             role: 'assistant',
                                             content: '',
                                             tool_calls: [toolCall],
-                                        });
+                                        };
+                                        if (currentTurnThinking) {
+                                            errorAssistantMsg.thinking = currentTurnThinking;
+                                        }
+                                        this.conversationHistory.push(errorAssistantMsg);
                                         this.conversationHistory.push({
                                             role: 'tool',
                                             tool_call_id: toolCall.id,
@@ -926,11 +983,15 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                                 }
                                 else {
                                     // Tool returned non-PLAN_CREATED result - add it to history
-                                    this.conversationHistory.push({
+                                    const resultAssistantMsg = {
                                         role: 'assistant',
                                         content: '',
                                         tool_calls: [toolCall],
-                                    });
+                                    };
+                                    if (currentTurnThinking) {
+                                        resultAssistantMsg.thinking = currentTurnThinking;
+                                    }
+                                    this.conversationHistory.push(resultAssistantMsg);
                                     this.conversationHistory.push({
                                         role: 'tool',
                                         tool_call_id: toolCall.id,
@@ -959,7 +1020,8 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                                             const mainTaskNum = parseInt(taskNumParts[0], 10) - 1;
                                             const task = currentPlanData.steps[mainTaskNum];
                                             if (task) {
-                                                this.onTaskCompleted(task, completion.taskNumber, completion.totalCount, completion.completionNote);
+                                                this.onTaskCompleted(task, completion.taskNumber, completion.totalCount, completion.completionNote, completion.taskDescription // Pass the actual task/subtask description
+                                                );
                                             }
                                         }
                                         // Notify UI about completed task/subtask
@@ -979,11 +1041,15 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                                                     result: `Task completed. Moving to Task ${nextPhase.taskNumber}: ${nextPhase.task.description}`,
                                                 });
                                                 // Add the tool call and result to history
-                                                this.conversationHistory.push({
+                                                const nextPhaseAssistantMsg = {
                                                     role: 'assistant',
                                                     content: '',
                                                     tool_calls: [toolCall],
-                                                });
+                                                };
+                                                if (currentTurnThinking) {
+                                                    nextPhaseAssistantMsg.thinking = currentTurnThinking;
+                                                }
+                                                this.conversationHistory.push(nextPhaseAssistantMsg);
                                                 this.conversationHistory.push({
                                                     role: 'tool',
                                                     tool_call_id: toolCall.id,
@@ -1216,12 +1282,16 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                     }
                     // If user cancelled an operation, stop the agentic loop immediately
                     if (userCancelledOperation) {
-                        // Add assistant message to history
-                        this.conversationHistory.push({
+                        // Add assistant message to history with thinking if available
+                        const cancelledAssistantMsg = {
                             role: 'assistant',
                             content: assistantMessage || '',
                             tool_calls: toolCalls, // Store tool calls for MaaS models
-                        });
+                        };
+                        if (currentTurnThinking) {
+                            cancelledAssistantMsg.thinking = currentTurnThinking;
+                        }
+                        this.conversationHistory.push(cancelledAssistantMsg);
                         // Add tool results to history
                         for (const toolResult of toolResults) {
                             this.conversationHistory.push({
@@ -1259,11 +1329,16 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                     const unhandledToolResults = toolResults.filter(tr => !handledToolCallIds.has(tr.tool_call_id));
                     // Only add assistant message if there are unhandled tool calls
                     if (unhandledToolCalls.length > 0) {
-                        this.conversationHistory.push({
+                        const assistantHistoryMsg = {
                             role: 'assistant',
                             content: assistantMessage || '',
                             tool_calls: unhandledToolCalls, // Only include unhandled tool calls
-                        });
+                        };
+                        // Include thinking from this turn if available (Extended Thinking pattern)
+                        if (currentTurnThinking) {
+                            assistantHistoryMsg.thinking = currentTurnThinking;
+                        }
+                        this.conversationHistory.push(assistantHistoryMsg);
                     }
                     // Add tool results to conversation history as tool messages
                     // Format: { tool_call_id, name, result: <object or string> }
@@ -1278,8 +1353,10 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                         });
                     }
                     // Rebuild messages array with updated history
-                    // Backend will inject system prompt
+                    // During agent loop: keep ALL thinking for current task
+                    // (Thinking from previous tasks was already stripped at request start)
                     messages = [...this.conversationHistory];
+                    // No need to reset currentTurnThinking - keep accumulating for the task
                     // Re-inject subshell context
                     messages = this.aiContextInjector.injectSubshellContext(messages, currentContext);
                     continue; // Loop back to AI service
@@ -1469,8 +1546,7 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                     role: 'assistant',
                     content: finalMessage,
                 });
-                // Save assistant message to backend
-                await this.saveMessageToBackend('assistant', finalMessage);
+                // Messages are stored locally only via saveCurrentChat() below
             } // End of while loop
             // Auto-save conversation to local storage
             this.saveCurrentChat();
@@ -1511,11 +1587,13 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                     `/init       - Analyze project and create/load centaurus.md context file\n` +
                     `/chat       - Manage chat sessions (resume previous chats)\n` +
                     `/clear      - Clear conversation and start a new chat\n` +
+                    `/sync       - Sync data to/from cloud (upload/restore)\n` +
                     `/config     - View current configuration\n` +
                     `/model      - Select from available Google models\n` +
                     `/plan       - Toggle plan mode for complex implementations\n` +
                     `/mcp        - Manage configured MCP servers and tools\n` +
                     `/docs       - Open Centaurus documentation in browser\n` +
+                    `/copy-chat-context - Copy chat as readable text to clipboard\n` +
                     `/quality    - Toggle enhanced quality features (thinking protocol, validation)\n` +
                     `/autonomous - Toggle autonomous mode (Silent Operator with task_complete)\n` +
                     `/sign-in    - Sign in with Google (if not already signed in)\n` +
@@ -1938,7 +2016,7 @@ Start by listing the directory structure to understand what you're working with.
                     // Show list of saved chats for resuming (interactive picker)
                     const chats = localChatStorage.listChats();
                     if (chats.length === 0) {
-                        responseMessage = '📭 No saved chats found.\\n\\nStart a new conversation and it will be automatically saved!';
+                        responseMessage = 'No saved chats found.\n\nStart a new conversation and it will be automatically saved!';
                     }
                     else {
                         // Format chat list for picker display
@@ -1948,13 +2026,13 @@ Start by listing the directory structure to understand what you're working with.
                         }
                         else {
                             // Fallback: show as text if no picker callback
-                            responseMessage = '📚 Saved Chats:\\n\\n' +
+                            responseMessage = 'Saved Chats:\n\n' +
                                 chats.slice(0, 10).map((chat, i) => {
                                     const date = new Date(chat.updatedAt).toLocaleDateString();
                                     const time = new Date(chat.updatedAt).toLocaleTimeString();
-                                    return `${i + 1}. ${chat.title}\\n   📅 ${date} ${time} | 💬 ${chat.messageCount} messages`;
-                                }).join('\\n\\n') +
-                                (chats.length > 10 ? `\\n\\n...and ${chats.length - 10} more chats` : '');
+                                    return `${i + 1}. ${chat.title}\n   ${date} ${time} | ${chat.messageCount} messages`;
+                                }).join('\n\n') +
+                                (chats.length > 10 ? `\n\n...and ${chats.length - 10} more chats` : '');
                         }
                     }
                 }
@@ -1962,7 +2040,7 @@ Start by listing the directory structure to understand what you're working with.
                     // Show read-only list of saved chats (no selection)
                     const chats = localChatStorage.listChats();
                     if (chats.length === 0) {
-                        responseMessage = '📭 No saved chats found.\\n\\nStart a new conversation and it will be automatically saved!';
+                        responseMessage = 'No saved chats found.\n\nStart a new conversation and it will be automatically saved!';
                     }
                     else {
                         // Format chat list for read-only display
@@ -1987,7 +2065,7 @@ Start by listing the directory structure to understand what you're working with.
                     // Show list of saved chats for deletion
                     const chats = localChatStorage.listChats();
                     if (chats.length === 0) {
-                        responseMessage = '📭 No saved chats to delete.';
+                        responseMessage = 'No saved chats to delete.';
                     }
                     else {
                         // Format chat list for delete picker display
@@ -2007,13 +2085,13 @@ Start by listing the directory structure to understand what you're working with.
                     if (this.onRestoreMessagesCallback) {
                         this.onRestoreMessagesCallback([]);
                     }
-                    responseMessage = '🆕 Started a new chat session!\n\nYour previous conversation has been saved and can be resumed with /chat resume.';
+                    responseMessage = '✅ Started a new chat session!\n\nYour previous conversation has been saved and can be resumed with /chat resume.';
                 }
                 else if (chatSubCommand === 'rename') {
                     // Show list of saved chats for renaming
                     const chats = localChatStorage.listChats();
                     if (chats.length === 0) {
-                        responseMessage = '📭 No saved chats to rename.';
+                        responseMessage = 'No saved chats to rename.';
                     }
                     else {
                         // Format chat list for rename picker display
@@ -2030,6 +2108,30 @@ Start by listing the directory structure to understand what you're working with.
                     responseMessage = `Unknown /chat subcommand: ${chatSubCommand}\\n\\nUsage:\\n  /chat resume  - Resume a previous chat session\\n  /chat list    - List all saved chats\\n  /chat delete  - Delete a saved chat\\n  /chat new     - Start a new chat session\\n  /chat rename  - Rename a saved chat`;
                 }
                 break;
+            case 'copy-chat-context':
+                try {
+                    const { formatChatForClipboard } = await import('./utils/chat-formatter.js');
+                    const { copyTextToClipboard } = await import('./utils/text-clipboard.js');
+                    if (this.uiMessageHistory.length === 0) {
+                        responseMessage = 'No messages in current chat to copy.';
+                    }
+                    else {
+                        const formattedChat = formatChatForClipboard(this.uiMessageHistory);
+                        const success = await copyTextToClipboard(formattedChat);
+                        if (success) {
+                            responseMessage = '✅ Chat content copied to clipboard!';
+                        }
+                        else {
+                            responseMessage = '❌ Failed to copy to clipboard.\n\n' +
+                                'This might happen if clipboard access is not available in your environment.\n' +
+                                'Try running the CLI in a terminal with clipboard access.';
+                        }
+                    }
+                }
+                catch (error) {
+                    responseMessage = `❌ Error copying chat content: ${error.message}`;
+                }
+                break;
             case 'exit':
                 process.exit(0);
                 break;
@@ -2147,6 +2249,138 @@ Start by listing the directory structure to understand what you're working with.
                         '  /background-task cancel  - Cancel a running background task';
                 }
                 break;
+            case 'sync':
+                // Sync local data to/from cloud
+                if (!apiClient.isAuthenticated()) {
+                    responseMessage = '❌ You must be signed in to sync data.\n\nUse /sign-in to authenticate first.';
+                    break;
+                }
+                // Parse subcommand
+                const syncSubcommand = args[0]?.toLowerCase();
+                if (!syncSubcommand) {
+                    // Show sync help
+                    responseMessage = '☁️  Sync Commands:\n\n' +
+                        '  /sync upload   - Upload local data to cloud (overwrites cloud data)\n' +
+                        '  /sync restore  - Download cloud data and restore locally (overwrites local data)\n\n' +
+                        'Use these commands to backup or restore your chat history and settings.';
+                    break;
+                }
+                if (syncSubcommand === 'upload') {
+                    try {
+                        responseMessage = '☁️  Uploading data to cloud...';
+                        // Send initial response
+                        if (this.onDirectMessageCallback) {
+                            this.onDirectMessageCallback(responseMessage);
+                        }
+                        // Gather all local data
+                        const config = this.configManager.load();
+                        const chats = localChatStorage.listChats();
+                        // Load full chat data for each chat
+                        const fullChats = chats.map(chatMeta => {
+                            const fullChat = localChatStorage.loadChat(chatMeta.id);
+                            return fullChat;
+                        }).filter(chat => chat !== null);
+                        // Create sync data structure
+                        const syncData = {
+                            version: 1,
+                            exportedAt: new Date().toISOString(),
+                            config: {
+                                model: config.model,
+                                modelName: config.modelName,
+                                enhancedQuality: config.enhancedQuality,
+                                autonomousMode: config.autonomousMode,
+                            },
+                            chats: fullChats,
+                            metadata: {
+                                totalChats: fullChats.length,
+                                totalMessages: fullChats.reduce((sum, chat) => sum + (chat?.messageCount || 0), 0),
+                            }
+                        };
+                        // Upload to backend
+                        const result = await apiClient.uploadSyncData(syncData);
+                        responseMessage = `✅ Data uploaded successfully!\n\n` +
+                            `📊 Upload Summary:\n` +
+                            `   • Chats: ${fullChats.length}\n` +
+                            `   • Messages: ${syncData.metadata.totalMessages}\n` +
+                            `   • Version: ${result.version}\n` +
+                            `   • Updated: ${new Date(result.updatedAt).toLocaleString()}\n\n` +
+                            `Your local data is now backed up to the cloud.`;
+                    }
+                    catch (error) {
+                        responseMessage = `❌ Upload failed: ${error.message}\n\nPlease try again later.`;
+                    }
+                }
+                else if (syncSubcommand === 'restore') {
+                    try {
+                        responseMessage = '☁️  Downloading data from cloud...';
+                        // Send initial response
+                        if (this.onDirectMessageCallback) {
+                            this.onDirectMessageCallback(responseMessage);
+                        }
+                        // Get sync data from backend
+                        const cloudData = await apiClient.getSyncData();
+                        if (!cloudData) {
+                            responseMessage = '❌ No cloud data found.\n\nUse /sync upload first to backup your data.';
+                            break;
+                        }
+                        const syncData = cloudData.syncData;
+                        // Validate sync data structure
+                        if (!syncData || typeof syncData !== 'object') {
+                            responseMessage = '❌ Invalid cloud data format.\n\nPlease try uploading again with /sync upload.';
+                            break;
+                        }
+                        // Restore config if present
+                        if (syncData.config) {
+                            const currentConfig = this.configManager.load();
+                            if (syncData.config.model) {
+                                currentConfig.model = syncData.config.model;
+                            }
+                            if (syncData.config.modelName) {
+                                currentConfig.modelName = syncData.config.modelName;
+                            }
+                            if (typeof syncData.config.enhancedQuality === 'boolean') {
+                                currentConfig.enhancedQuality = syncData.config.enhancedQuality;
+                            }
+                            if (typeof syncData.config.autonomousMode === 'boolean') {
+                                currentConfig.autonomousMode = syncData.config.autonomousMode;
+                            }
+                            this.configManager.save(currentConfig);
+                        }
+                        // Restore chats if present
+                        let restoredChats = 0;
+                        let restoredMessages = 0;
+                        if (syncData.chats && Array.isArray(syncData.chats)) {
+                            for (const chat of syncData.chats) {
+                                if (chat && chat.id) {
+                                    // Import each chat to local storage
+                                    const success = localChatStorage.importChat(chat);
+                                    if (success) {
+                                        restoredChats++;
+                                        restoredMessages += chat.messageCount || chat.messages?.length || 0;
+                                    }
+                                }
+                            }
+                        }
+                        responseMessage = `✅ Data restored successfully!\n\n` +
+                            `📊 Restore Summary:\n` +
+                            `   • Chats restored: ${restoredChats}\n` +
+                            `   • Messages restored: ${restoredMessages}\n` +
+                            `   • Cloud version: ${cloudData.version}\n` +
+                            `   • Last updated: ${new Date(cloudData.updatedAt).toLocaleString()}\n\n` +
+                            `Your local data has been restored from the cloud.\n` +
+                            `Note: Existing local chats with the same ID were overwritten.`;
+                    }
+                    catch (error) {
+                        responseMessage = `❌ Restore failed: ${error.message}\n\nPlease try again later.`;
+                    }
+                }
+                else {
+                    responseMessage = `❌ Unknown sync subcommand: ${syncSubcommand}\n\n` +
+                        'Available subcommands:\n' +
+                        '  /sync upload   - Upload local data to cloud\n' +
+                        '  /sync restore  - Download and restore cloud data locally';
+                }
+                break;
             default:
                 responseMessage = `Unknown command: /${cmd}\nType /help for available commands.`;
         }