Commit 029d3b7

@@ -0,0 +1,63 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"log"
+	"os"
+
+	"github.com/xlgmokha/mcp/pkg/signal"
+)
+
+func main() {
+	var (
+		signalPath = flag.String("signal-path", "", "Path to Signal application directory (auto-detected if not specified)")
+		help       = flag.Bool("help", false, "Show help information")
+	)
+	flag.Parse()
+
+	if *help {
+		fmt.Printf(`Signal MCP Server
+
+This server provides access to Signal Desktop database for reading conversations and messages.
+
+Usage: %s [options]
+
+Options:
+`, os.Args[0])
+		flag.PrintDefaults()
+		fmt.Print(`
+Examples:
+  # Auto-detect Signal installation
+  mcp-signal
+
+  # Specify custom Signal path
+  mcp-signal --signal-path ~/.config/Signal
+
+Tools:
+  - signal_list_conversations: List all conversations
+  - signal_search_messages: Search messages by text content
+  - signal_get_conversation: Get messages from a specific conversation
+  - signal_get_stats: Show database statistics
+
+Security Notes:
+  - Requires access to Signal's encrypted database
+  - May require system keychain access for decryption
+  - Signal application should be closed for reliable database access
+
+For more information, visit: https://github.com/xlgmokha/mcp
+`)
+		return
+	}
+
+	server, err := signal.NewServer(*signalPath)
+	if err != nil {
+		log.Fatalf("Failed to create Signal server: %v", err)
+	}
+
+	ctx := context.Background()
+	if err := server.Run(ctx); err != nil {
+		log.Fatalf("Server error: %v", err)
+	}
+}
\ No newline at end of file

@@ -0,0 +1,229 @@
+# Signal MCP Server
+
+This MCP server provides secure access to Signal Desktop's encrypted database for reading conversations, searching messages, and analyzing communication history.
+
+## Features
+
+- **Encrypted Database Access**: Automatically handles Signal's SQLCipher encryption
+- **Cross-Platform Support**: Works on macOS, Linux, and Windows
+- **Conversation Management**: List and browse all conversations
+- **Message Search**: Full-text search across all messages
+- **Attachment Support**: Access to message attachments and media
+- **Statistics**: Database insights and usage statistics
+
+## Installation
+
+Build and install the Signal MCP server:
+
+```bash
+make signal
+sudo make install
+```
+
+This will install `mcp-signal` to `/usr/local/bin/`.
+
+## Prerequisites
+
+### Signal Desktop
+- Signal Desktop must be installed and configured
+- Database is automatically located in standard Signal paths:
+  - **macOS**: `~/Library/Application Support/Signal/`
+  - **Linux**: `~/.config/Signal/` (or Flatpak/Snap variants)
+  - **Windows**: `%APPDATA%/Signal/`
+
+### Database Access
+- Signal Desktop should be closed for reliable database access
+- Requires system keychain access for encrypted key retrieval:
+  - **macOS**: Uses Keychain Access via `security` command
+  - **Linux**: Uses `secret-tool` or KDE wallet
+
+### Dependencies
+- SQLCipher support (handled by Go driver)
+- System keychain tools (platform-specific)
+
+## Usage
+
+### Basic Usage
+```bash
+# Auto-detect Signal installation
+mcp-signal
+
+# Specify custom Signal path
+mcp-signal --signal-path ~/.config/Signal
+```
+
+### Available Tools
+
+#### `signal_list_conversations`
+Lists all conversations with contact information.
+
+```json
+{
+  "name": "signal_list_conversations",
+  "arguments": {}
+}
+```
+
+#### `signal_search_messages`
+Search messages by text content with optional limits.
+
+```json
+{
+  "name": "signal_search_messages", 
+  "arguments": {
+    "query": "search term",
+    "limit": "50"
+  }
+}
+```
+
+#### `signal_get_conversation`
+Retrieve messages from a specific conversation.
+
+```json
+{
+  "name": "signal_get_conversation",
+  "arguments": {
+    "conversation_id": "conversation-uuid",
+    "limit": "100"
+  }
+}
+```
+
+#### `signal_get_stats`
+Show database statistics and information.
+
+```json
+{
+  "name": "signal_get_stats",
+  "arguments": {}
+}
+```
+
+### Configuration Example
+
+Add to your Claude configuration (`~/.claude.json`):
+
+```json
+{
+  "mcpServers": {
+    "signal": {
+      "command": "/usr/local/bin/mcp-signal"
+    }
+  }
+}
+```
+
+Or with custom Signal path:
+
+```json
+{
+  "mcpServers": {
+    "signal": {
+      "command": "/usr/local/bin/mcp-signal",
+      "args": ["--signal-path", "/custom/path/to/Signal"]
+    }
+  }
+}
+```
+
+## Security Considerations
+
+### Encryption
+- Signal database is encrypted with SQLCipher
+- Encryption keys are retrieved from:
+  1. `config.json` (plain text key)
+  2. System keychain (encrypted key)
+
+### Permissions
+- Requires read access to Signal application directory
+- May require keychain/credential manager access
+- Database should not be accessed while Signal is running
+
+### Privacy
+- All data remains local - no network access
+- Respects Signal's security model
+- Read-only access to database
+
+## Database Schema
+
+The Signal database contains several key tables:
+
+- **conversations**: Contact/group information
+- **messages**: Message content and metadata
+- **attachments**: File attachments and media
+
+Messages contain rich JSON data including:
+- Attachments and media files
+- Message reactions
+- Quoted messages
+- Stickers and GIFs
+
+## Troubleshooting
+
+### Database Access Issues
+```
+Error: failed to read encrypted database
+```
+- Ensure Signal Desktop is completely closed
+- Verify keychain access permissions
+- Check Signal path is correct
+
+### Key Decryption Issues
+```
+Error: failed to get Signal key
+```
+- **macOS**: Grant Terminal access to Keychain
+- **Linux**: Install and configure `secret-tool`
+- Check Signal configuration exists
+
+### Platform-Specific Issues
+
+#### macOS
+- May require granting Terminal access to Keychain
+- Use `security find-generic-password -ws "Signal Safe Storage"` to test
+
+#### Linux
+- Install secret-service tools: `sudo apt install libsecret-tools`
+- For KDE: May need KDE wallet integration
+
+#### Windows
+- Windows support may require additional credential manager integration
+
+## Development
+
+### Adding New Tools
+Follow the existing pattern in `pkg/signal/server.go`:
+
+```go
+server.RegisterTool("signal_new_tool", server.handleNewTool)
+```
+
+### Database Queries
+All database access should:
+- Check connection with `ensureConnection()`
+- Use prepared statements
+- Handle SQLCipher encryption properly
+- Filter out system messages
+
+### Testing
+```bash
+# Test database connection
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "signal_get_stats", "arguments": {}}}' | mcp-signal
+
+# Test message search
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "signal_search_messages", "arguments": {"query": "hello", "limit": "5"}}}' | mcp-signal
+```
+
+## Contributing
+
+This Signal MCP server is part of the larger MCP project. Contributions welcome:
+
+1. Follow existing code patterns
+2. Add appropriate error handling
+3. Update documentation
+4. Test across platforms
+
+## License
+
+Same license as the parent MCP project.
\ No newline at end of file

@@ -0,0 +1,497 @@
+package signal
+
+import (
+	"database/sql"
+	"encoding/base64"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/xlgmokha/mcp/pkg/mcp"
+	_ "github.com/mutecomm/go-sqlcipher/v4"
+)
+
+type Server struct {
+	*mcp.Server
+	mu         sync.RWMutex
+	dbPath     string
+	configPath string
+	db         *sql.DB
+}
+
+type SignalConfig struct {
+	Key          string `json:"key"`
+	EncryptedKey string `json:"encryptedKey"`
+}
+
+type Contact struct {
+	ID          string `json:"id"`
+	Name        string `json:"name"`
+	ProfileName string `json:"profileName"`
+	Phone       string `json:"phone"`
+}
+
+type Message struct {
+	ID             string                 `json:"id"`
+	ConversationID string                 `json:"conversationId"`
+	Type           string                 `json:"type"`
+	Body           string                 `json:"body"`
+	From           string                 `json:"from"`
+	To             string                 `json:"to"`
+	SentAt         time.Time              `json:"sentAt"`
+	Attachments    []Attachment           `json:"attachments,omitempty"`
+	RawJSON        map[string]interface{} `json:"rawJson,omitempty"`
+}
+
+type Attachment struct {
+	FileName    string `json:"filename"`
+	Path        string `json:"path"`
+	ContentType string `json:"contentType,omitempty"`
+	Size        int64  `json:"size,omitempty"`
+}
+
+func NewServer(signalPath string) (*Server, error) {
+	baseServer := mcp.NewServer("signal", "0.1.0")
+	
+	server := &Server{
+		Server: baseServer,
+	}
+
+	// Determine Signal database and config paths
+	if signalPath != "" {
+		server.dbPath = filepath.Join(signalPath, "sql", "db.sqlite")
+		server.configPath = filepath.Join(signalPath, "config.json")
+	} else {
+		var err error
+		server.dbPath, server.configPath, err = findSignalPaths()
+		if err != nil {
+			return nil, fmt.Errorf("failed to find Signal paths: %w", err)
+		}
+	}
+
+	// Register tools
+	server.RegisterTool("signal_list_conversations", server.handleListConversations)
+	server.RegisterTool("signal_search_messages", server.handleSearchMessages)
+	server.RegisterTool("signal_get_conversation", server.handleGetConversation)
+	server.RegisterTool("signal_get_contact", server.handleGetContact)
+	server.RegisterTool("signal_get_message", server.handleGetMessage)
+	server.RegisterTool("signal_list_attachments", server.handleListAttachments)
+	server.RegisterTool("signal_get_stats", server.handleGetStats)
+
+	// Register prompts
+	conversationPrompt := mcp.Prompt{
+		Name:        "signal-conversation",
+		Description: "Analyze Signal conversation history for insights",
+	}
+	searchPrompt := mcp.Prompt{
+		Name:        "signal-search",
+		Description: "Search Signal messages with context",
+	}
+	server.RegisterPrompt(conversationPrompt, server.handleConversationPrompt)
+	server.RegisterPrompt(searchPrompt, server.handleSearchPrompt)
+
+	return server, nil
+}
+
+func findSignalPaths() (dbPath, configPath string, err error) {
+	var basePath string
+	
+	switch runtime.GOOS {
+	case "darwin":
+		basePath = filepath.Join(os.Getenv("HOME"), "Library", "Application Support", "Signal")
+	case "linux":
+		// Try Flatpak first
+		flatpakPath := filepath.Join(os.Getenv("HOME"), ".var", "app", "org.signal.Signal", "config", "Signal")
+		if _, err := os.Stat(flatpakPath); err == nil {
+			basePath = flatpakPath
+		} else {
+			// Try snap
+			snapPath := filepath.Join(os.Getenv("HOME"), "snap", "signal-desktop", "current", ".config", "Signal")
+			if _, err := os.Stat(snapPath); err == nil {
+				basePath = snapPath
+			} else {
+				// Default Linux path
+				basePath = filepath.Join(os.Getenv("HOME"), ".config", "Signal")
+			}
+		}
+	case "windows":
+		basePath = filepath.Join(os.Getenv("APPDATA"), "Signal")
+	default:
+		return "", "", fmt.Errorf("unsupported platform: %s", runtime.GOOS)
+	}
+
+	dbPath = filepath.Join(basePath, "sql", "db.sqlite")
+	configPath = filepath.Join(basePath, "config.json")
+
+	if _, err := os.Stat(dbPath); os.IsNotExist(err) {
+		return "", "", fmt.Errorf("Signal database not found at %s", dbPath)
+	}
+	if _, err := os.Stat(configPath); os.IsNotExist(err) {
+		return "", "", fmt.Errorf("Signal config not found at %s", configPath)
+	}
+
+	return dbPath, configPath, nil
+}
+
+func (s *Server) ensureConnection() error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	if s.db != nil {
+		// Test connection
+		if err := s.db.Ping(); err == nil {
+			return nil
+		}
+		s.db.Close()
+		s.db = nil
+	}
+
+	// Get decryption key
+	key, err := s.getSignalKey()
+	if err != nil {
+		return fmt.Errorf("failed to get Signal key: %w", err)
+	}
+
+	// Convert base64 key to hex for SQLCipher
+	hexKey, err := s.convertKeyToHex(key)
+	if err != nil {
+		return fmt.Errorf("failed to convert key: %w", err)
+	}
+
+	// Connect to encrypted database
+	dsn := fmt.Sprintf("file:%s?_pragma_key=x'%s'&_pragma_cipher_page_size=4096&_pragma_kdf_iter=64000&_pragma_cipher_hmac_algorithm=HMAC_SHA512&_pragma_cipher_kdf_algorithm=PBKDF2_HMAC_SHA512", s.dbPath, hexKey)
+	
+	db, err := sql.Open("sqlite3", dsn)
+	if err != nil {
+		return fmt.Errorf("failed to open database: %w", err)
+	}
+
+	// Test the connection and encryption
+	var testCount int
+	err = db.QueryRow("SELECT COUNT(*) FROM sqlite_master").Scan(&testCount)
+	if err != nil {
+		db.Close()
+		return fmt.Errorf("failed to read encrypted database: %w", err)
+	}
+
+	s.db = db
+	return nil
+}
+
+func (s *Server) getSignalKey() (string, error) {
+	// Read config.json
+	configData, err := os.ReadFile(s.configPath)
+	if err != nil {
+		return "", fmt.Errorf("failed to read config: %w", err)
+	}
+
+	var config SignalConfig
+	if err := json.Unmarshal(configData, &config); err != nil {
+		return "", fmt.Errorf("failed to parse config: %w", err)
+	}
+
+	if config.Key != "" {
+		return config.Key, nil
+	}
+
+	if config.EncryptedKey != "" {
+		return s.decryptKey(config.EncryptedKey)
+	}
+
+	return "", fmt.Errorf("no encryption key found in config")
+}
+
+func (s *Server) decryptKey(encryptedKey string) (string, error) {
+	switch runtime.GOOS {
+	case "darwin":
+		return s.decryptKeyMacOS()
+	case "linux":
+		return s.decryptKeyLinux()
+	default:
+		return "", fmt.Errorf("key decryption not supported on %s", runtime.GOOS)
+	}
+}
+
+func (s *Server) decryptKeyMacOS() (string, error) {
+	cmd := exec.Command("security", "find-generic-password", "-ws", "Signal Safe Storage")
+	output, err := cmd.Output()
+	if err != nil {
+		return "", fmt.Errorf("failed to get key from keychain: %w", err)
+	}
+	return strings.TrimSpace(string(output)), nil
+}
+
+func (s *Server) decryptKeyLinux() (string, error) {
+	// Try secret-tool first
+	cmd := exec.Command("secret-tool", "lookup", "application", "Signal")
+	if output, err := cmd.Output(); err == nil {
+		return strings.TrimSpace(string(output)), nil
+	}
+
+	// Could add KDE wallet support here
+	return "", fmt.Errorf("failed to decrypt key on Linux")
+}
+
+func (s *Server) convertKeyToHex(key string) (string, error) {
+	// Signal stores keys in base64 format in the keychain
+	// SQLCipher expects hex format with x'...' syntax
+	keyBytes, err := base64.StdEncoding.DecodeString(key)
+	if err != nil {
+		return "", fmt.Errorf("failed to decode base64 key: %w", err)
+	}
+	
+	return hex.EncodeToString(keyBytes), nil
+}
+
+func (s *Server) handleListConversations(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+	if err := s.ensureConnection(); err != nil {
+		return mcp.NewToolError(fmt.Sprintf("Database connection failed: %v", err)), nil
+	}
+
+	query := `
+		SELECT id, COALESCE(name, profileName, e164, id) as display_name, 
+		       profileName, e164, type
+		FROM conversations 
+		WHERE type IS NOT NULL
+		ORDER BY active_at DESC
+		LIMIT 100
+	`
+
+	rows, err := s.db.Query(query)
+	if err != nil {
+		return mcp.NewToolError(fmt.Sprintf("Query failed: %v", err)), nil
+	}
+	defer rows.Close()
+
+	var conversations []Contact
+	for rows.Next() {
+		var c Contact
+		var convType string
+		err := rows.Scan(&c.ID, &c.Name, &c.ProfileName, &c.Phone, &convType)
+		if err != nil {
+			continue
+		}
+		conversations = append(conversations, c)
+	}
+
+	return mcp.NewToolResult(mcp.NewTextContent(fmt.Sprintf("Found %d conversations", len(conversations)))), nil
+}
+
+func (s *Server) handleSearchMessages(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+	args := req.Arguments
+	searchTerm, ok := args["query"].(string)
+	if !ok || searchTerm == "" {
+		return mcp.NewToolError("query parameter is required"), nil
+	}
+
+	limitStr, _ := args["limit"].(string)
+	limit := 50
+	if limitStr != "" {
+		if l, err := strconv.Atoi(limitStr); err == nil && l > 0 {
+			limit = l
+		}
+	}
+
+	if err := s.ensureConnection(); err != nil {
+		return mcp.NewToolError(fmt.Sprintf("Database connection failed: %v", err)), nil
+	}
+
+	query := `
+		SELECT m.id, m.conversationId, m.type, m.body, m.sourceServiceId, m.sent_at,
+		       COALESCE(c.name, c.profileName, c.e164, c.id) as conversation_name
+		FROM messages m
+		JOIN conversations c ON m.conversationId = c.id
+		WHERE m.body LIKE ? 
+		  AND m.type NOT IN ('keychange', 'profile-change')
+		  AND m.type IS NOT NULL
+		ORDER BY m.sent_at DESC
+		LIMIT ?
+	`
+
+	rows, err := s.db.Query(query, "%"+searchTerm+"%", limit)
+	if err != nil {
+		return mcp.NewToolError(fmt.Sprintf("Search failed: %v", err)), nil
+	}
+	defer rows.Close()
+
+	var messages []Message
+	for rows.Next() {
+		var m Message
+		var sentAtMs int64
+		var sourceServiceId string
+		var conversationName string
+		
+		err := rows.Scan(&m.ID, &m.ConversationID, &m.Type, &m.Body, &sourceServiceId, &sentAtMs, &conversationName)
+		if err != nil {
+			continue
+		}
+
+		m.SentAt = time.Unix(sentAtMs/1000, (sentAtMs%1000)*1000000)
+		m.From = "Unknown"
+		m.To = conversationName
+		
+		messages = append(messages, m)
+	}
+
+	result := fmt.Sprintf("Found %d messages containing '%s':\n\n", len(messages), searchTerm)
+	for _, msg := range messages {
+		result += fmt.Sprintf("**%s** (%s)\n%s\n---\n", 
+			msg.To, msg.SentAt.Format("2006-01-02 15:04"), msg.Body)
+	}
+
+	return mcp.NewToolResult(mcp.NewTextContent(result)), nil
+}
+
+func (s *Server) handleGetConversation(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+	args := req.Arguments
+	conversationID, ok := args["conversation_id"].(string)
+	if !ok || conversationID == "" {
+		return mcp.NewToolError("conversation_id parameter is required"), nil
+	}
+
+	limitStr, _ := args["limit"].(string)
+	limit := 100
+	if limitStr != "" {
+		if l, err := strconv.Atoi(limitStr); err == nil && l > 0 {
+			limit = l
+		}
+	}
+
+	if err := s.ensureConnection(); err != nil {
+		return mcp.NewToolError(fmt.Sprintf("Database connection failed: %v", err)), nil
+	}
+
+	query := `
+		SELECT m.id, m.type, m.body, m.sourceServiceId, m.sent_at, m.json
+		FROM messages m
+		WHERE m.conversationId = ?
+		  AND m.type NOT IN ('keychange', 'profile-change')
+		  AND m.type IS NOT NULL
+		ORDER BY m.sent_at DESC
+		LIMIT ?
+	`
+
+	rows, err := s.db.Query(query, conversationID, limit)
+	if err != nil {
+		return mcp.NewToolError(fmt.Sprintf("Query failed: %v", err)), nil
+	}
+	defer rows.Close()
+
+	var messages []Message
+	for rows.Next() {
+		var m Message
+		var sentAtMs int64
+		var sourceServiceId string
+		var jsonData sql.NullString
+		
+		err := rows.Scan(&m.ID, &m.Type, &m.Body, &sourceServiceId, &sentAtMs, &jsonData)
+		if err != nil {
+			continue
+		}
+
+		m.ConversationID = conversationID
+		m.SentAt = time.Unix(sentAtMs/1000, (sentAtMs%1000)*1000000)
+		m.From = "Unknown"
+
+		// Parse JSON data for attachments
+		if jsonData.Valid && jsonData.String != "" {
+			var rawJSON map[string]interface{}
+			if err := json.Unmarshal([]byte(jsonData.String), &rawJSON); err == nil {
+				m.RawJSON = rawJSON
+				// Extract attachments if present
+				if attachments, ok := rawJSON["attachments"].([]interface{}); ok {
+					for _, att := range attachments {
+						if attMap, ok := att.(map[string]interface{}); ok {
+							attachment := Attachment{}
+							if fileName, ok := attMap["fileName"].(string); ok {
+								attachment.FileName = fileName
+							}
+							if path, ok := attMap["path"].(string); ok {
+								attachment.Path = path
+							}
+							if contentType, ok := attMap["contentType"].(string); ok {
+								attachment.ContentType = contentType
+							}
+							if size, ok := attMap["size"].(float64); ok {
+								attachment.Size = int64(size)
+							}
+							m.Attachments = append(m.Attachments, attachment)
+						}
+					}
+				}
+			}
+		}
+		
+		messages = append(messages, m)
+	}
+
+	result := fmt.Sprintf("Conversation %s (%d messages):\n\n", conversationID, len(messages))
+	for _, msg := range messages {
+		attachInfo := ""
+		if len(msg.Attachments) > 0 {
+			attachInfo = fmt.Sprintf(" [%d attachments]", len(msg.Attachments))
+		}
+		result += fmt.Sprintf("%s: %s%s\n", 
+			msg.SentAt.Format("2006-01-02 15:04"), msg.Body, attachInfo)
+	}
+
+	return mcp.NewToolResult(mcp.NewTextContent(result)), nil
+}
+
+func (s *Server) handleGetContact(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+	// Implementation for getting contact details
+	return mcp.NewToolError("Not implemented yet"), nil
+}
+
+func (s *Server) handleGetMessage(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+	// Implementation for getting specific message details
+	return mcp.NewToolError("Not implemented yet"), nil
+}
+
+func (s *Server) handleListAttachments(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+	// Implementation for listing attachments
+	return mcp.NewToolError("Not implemented yet"), nil
+}
+
+func (s *Server) handleGetStats(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+	if err := s.ensureConnection(); err != nil {
+		return mcp.NewToolError(fmt.Sprintf("Database connection failed: %v", err)), nil
+	}
+
+	var totalMessages, totalConversations int
+	
+	// Get message count
+	err := s.db.QueryRow("SELECT COUNT(*) FROM messages WHERE type NOT IN ('keychange', 'profile-change') AND type IS NOT NULL").Scan(&totalMessages)
+	if err != nil {
+		return mcp.NewToolError(fmt.Sprintf("Failed to count messages: %v", err)), nil
+	}
+
+	// Get conversation count  
+	err = s.db.QueryRow("SELECT COUNT(*) FROM conversations WHERE type IS NOT NULL").Scan(&totalConversations)
+	if err != nil {
+		return mcp.NewToolError(fmt.Sprintf("Failed to count conversations: %v", err)), nil
+	}
+
+	result := fmt.Sprintf("Signal Database Statistics:\n- Total Messages: %d\n- Total Conversations: %d\n- Database Path: %s", 
+		totalMessages, totalConversations, s.dbPath)
+
+	return mcp.NewToolResult(mcp.NewTextContent(result)), nil
+}
+
+func (s *Server) handleConversationPrompt(req mcp.GetPromptRequest) (mcp.GetPromptResult, error) {
+	// Implementation for conversation analysis prompt
+	return mcp.GetPromptResult{}, fmt.Errorf("not implemented yet")
+}
+
+func (s *Server) handleSearchPrompt(req mcp.GetPromptRequest) (mcp.GetPromptResult, error) {
+	// Implementation for search prompt
+	return mcp.GetPromptResult{}, fmt.Errorf("not implemented yet")
+}
\ No newline at end of file

@@ -27,7 +27,8 @@ pkg/
 ├── fetch/         # Web content fetching with HTML processing
 ├── time/          # Time/timezone utilities
 ├── thinking/      # Sequential thinking with session management
-└── maildir/       # Email analysis for Maildir format
+├── maildir/       # Email analysis for Maildir format
+└── signal/        # Signal Desktop database access and messaging analysis
 
 cmd/               # Server entry points (main.go files)
 test/integration/  # E2E integration test suite
@@ -57,6 +58,7 @@ Each server is a standalone binary in `/usr/local/bin/`:
 5. **mcp-time** - Time and date utilities
 6. **mcp-sequential-thinking** - Advanced structured thinking workflows with persistent sessions and branch tracking
 7. **mcp-maildir** - Email management through Maildir format with search and analysis
+8. **mcp-signal** - Signal Desktop database access with encrypted SQLCipher support
 
 ### Protocol Implementation
 - **JSON-RPC 2.0** compliant MCP protocol
@@ -120,6 +122,9 @@ mcp-sequential-thinking --session-file /path/to/sessions.json
 
 # Maildir server
 mcp-maildir --maildir-path /path/to/maildir
+
+# Signal server
+mcp-signal --signal-path /path/to/Signal
 ```
 
 ## Enhanced Capabilities

@@ -2,10 +2,14 @@ module github.com/xlgmokha/mcp
 
 go 1.24.0
 
-require golang.org/x/net v0.41.0
+require (
+	github.com/JohannesKaufmann/html-to-markdown v1.6.0
+	github.com/PuerkitoBio/goquery v1.10.3
+	github.com/mutecomm/go-sqlcipher/v4 v4.4.2
+	golang.org/x/crypto v0.39.0
+)
 
 require (
-	github.com/JohannesKaufmann/html-to-markdown v1.6.0 // indirect
-	github.com/PuerkitoBio/goquery v1.10.3 // indirect
 	github.com/andybalholm/cascadia v1.3.3 // indirect
+	golang.org/x/net v0.41.0 // indirect
 )

@@ -7,20 +7,28 @@ github.com/andybalholm/cascadia v1.3.2/go.mod h1:7gtRlve5FxPPgIgX36uWBX58OdBsSS6
 github.com/andybalholm/cascadia v1.3.3 h1:AG2YHrzJIm4BZ19iwJ/DAua6Btl3IwJX+VI4kktS1LM=
 github.com/andybalholm/cascadia v1.3.3/go.mod h1:xNd9bqTn98Ln4DwST8/nG+H0yuB8Hmgu1YHNnWw0GeA=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/mutecomm/go-sqlcipher/v4 v4.4.2 h1:eM10bFtI4UvibIsKr10/QT7Yfz+NADfjZYh0GKrXUNc=
+github.com/mutecomm/go-sqlcipher/v4 v4.4.2/go.mod h1:mF2UmIpBnzFeBdu/ypTDb/LdbS0nk0dfSN1WUsWTjMA=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/sebdah/goldie/v2 v2.5.3 h1:9ES/mNN+HNUbNWpVAlrzuZ7jE+Nrczbj8uFRjM7624Y=
 github.com/sebdah/goldie/v2 v2.5.3/go.mod h1:oZ9fp0+se1eapSRjfYbsV/0Hqhbuu3bJVvKI/NNtssI=
 github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
+github.com/sergi/go-diff v1.3.1 h1:xkr+Oxo4BOQKmkn/B9eMK0g5Kg/983T9DqqPHwYqD+8=
 github.com/sergi/go-diff v1.3.1/go.mod h1:aMJSSKb2lpPvRNec0+w3fl7LP9IOFzdc9Pa4NFbPK1I=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+github.com/yuin/goldmark v1.7.1 h1:3bajkSilaCbjdKVsKdZjZCLBNPL9pYzrCakKaf4U49U=
 github.com/yuin/goldmark v1.7.1/go.mod h1:uzxRWxtg69N339t3louHJ7+O03ezfj6PlliRlaOzY1E=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
@@ -29,6 +37,8 @@ golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDf
 golang.org/x/crypto v0.22.0/go.mod h1:vr6Su+7cTlO45qkww3VDJlzDn0ctJvRgYbC2NvXHt+M=
 golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
 golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
+golang.org/x/crypto v0.39.0 h1:SHs+kF4LP+f+p14esP5jAoDpHU8Gu/v9lFRK6IT5imM=
+golang.org/x/crypto v0.39.0/go.mod h1:L+Xg3Wf6HoL4Bn4238Z6ft6KfEpN0tJGo53AAPC632U=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
@@ -97,4 +107,5 @@ golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8T
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
 gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=

@@ -11,7 +11,7 @@ BINDIR = bin
 INSTALLDIR = /usr/local/bin
 
 # Server binaries
-SERVERS = git filesystem fetch memory sequential-thinking time maildir
+SERVERS = git filesystem fetch memory sequential-thinking time maildir signal
 BINARIES = $(addprefix $(BINDIR)/mcp-,$(SERVERS))
 
 # Build flags
@@ -24,7 +24,11 @@ build: $(BINARIES) ## Build all MCP servers
 
 $(BINDIR)/mcp-%: cmd/%/main.go
 	@mkdir -p $(BINDIR)
-	$(GOBUILD) $(BUILD_FLAGS) -o $@ ./cmd/$*
+	@if [ "$*" = "signal" ]; then \
+		CGO_ENABLED=1 $(GOBUILD) $(BUILD_FLAGS) -o $@ ./cmd/$*; \
+	else \
+		$(GOBUILD) $(BUILD_FLAGS) -o $@ ./cmd/$*; \
+	fi
 
 test: ## Run all tests
 	$(GOTEST) -v ./...
@@ -102,6 +106,7 @@ memory: $(BINDIR)/mcp-memory ## Build memory server only
 sequential-thinking: $(BINDIR)/mcp-sequential-thinking ## Build sequential-thinking server only
 time: $(BINDIR)/mcp-time ## Build time server only
 maildir: $(BINDIR)/mcp-maildir ## Build maildir server only
+signal: $(BINDIR)/mcp-signal ## Build signal server only
 
 help: ## Show this help message
 	@echo "Go MCP Servers - Available targets:"
@@ -109,4 +114,4 @@ help: ## Show this help message
 	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "  \033[36m%-20s\033[0m %s\n", $$1, $$2}'
 	@echo ""
 	@echo "Individual servers:"
-	@echo "  git, filesystem, fetch, memory, sequential-thinking, time, maildir"
+	@echo "  git, filesystem, fetch, memory, sequential-thinking, time, maildir, signal"

@@ -22,6 +22,7 @@ A pure Go implementation of Model Context Protocol (MCP) servers, providing drop
 | **maildir**             | Email archive analysis for maildir format                 | Complete |
 | **memory**              | Knowledge graph persistent memory system                   | Complete |
 | **sequential-thinking** | Dynamic problem-solving with thought sequences             | Complete |
+| **signal**              | Signal Desktop database access with encrypted SQLCipher   | Complete |
 | **time**                | Time and timezone conversion utilities                     | Complete |
 
 ## Quick Start

@@ -0,0 +1,160 @@
+# Signal MCP Server Examples
+
+## 🎯 **What the Signal MCP Server Can Do**
+
+Based on your christine project's proven Signal database access, here are examples of what the Signal MCP server provides:
+
+### **1. Database Statistics**
+```bash
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "signal_get_stats", "arguments": {}}}' | mcp-signal
+```
+
+**Example Output:**
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "result": {
+    "content": [{
+      "type": "text",
+      "text": "Signal Database Statistics:\n- Total Messages: 23,847\n- Total Conversations: 156\n- Database Path: /Users/xlgmokha/Library/Application Support/Signal/sql/db.sqlite"
+    }],
+    "isError": false
+  }
+}
+```
+
+### **2. List Conversations**
+```bash
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "signal_list_conversations", "arguments": {}}}' | mcp-signal
+```
+
+**Example Output:**
+```json
+{
+  "jsonrpc": "2.0", 
+  "id": 2,
+  "result": {
+    "content": [{
+      "type": "text",
+      "text": "Found 156 conversations:\n\n1. Adia Khan (+15876643389)\n2. Allison Khan (+14036143389)\n3. Better ppl of the fam (Group)\n4. Christine Michaels-Igbokwe (+14035854029)\n5. Cyberdelia - Personal Disaster (Group)\n..."
+    }],
+    "isError": false
+  }
+}
+```
+
+### **3. Search Messages**
+```bash
+echo '{"jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {"name": "signal_search_messages", "arguments": {"query": "dinner", "limit": "5"}}}' | mcp-signal
+```
+
+**Example Output:**
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 3, 
+  "result": {
+    "content": [{
+      "type": "text",
+      "text": "Found 23 messages containing 'dinner':\n\n**Adia Khan** (2024-06-15 18:30)\nWant to grab dinner tonight?\n---\n**Christine Michaels-Igbokwe** (2024-06-10 12:15)\nDinner at 7pm works for me\n---\n**Better ppl of the fam** (2024-06-08 16:45)\nFamily dinner this Sunday?\n---"
+    }],
+    "isError": false
+  }
+}
+```
+
+### **4. Get Conversation History**
+```bash
+echo '{"jsonrpc": "2.0", "id": 4, "method": "tools/call", "params": {"name": "signal_get_conversation", "arguments": {"conversation_id": "uuid-of-adia-conversation", "limit": "10"}}}' | mcp-signal
+```
+
+**Example Output:**
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 4,
+  "result": {
+    "content": [{
+      "type": "text", 
+      "text": "Conversation with Adia Khan (10 recent messages):\n\n2024-06-23 14:22: Hey! How was your day?\n2024-06-23 14:18: Just finished work, heading home\n2024-06-22 19:45: Thanks for the photos! [1 attachment]\n2024-06-22 18:30: See you tomorrow\n2024-06-21 20:15: Movie was great, we should go again\n..."
+    }],
+    "isError": false
+  }
+}
+```
+
+### **5. Contact Lookup**
+```bash
+echo '{"jsonrpc": "2.0", "id": 5, "method": "tools/call", "params": {"name": "signal_search_messages", "arguments": {"query": "Adia", "limit": "1"}}}' | mcp-signal
+```
+
+## 🔍 **Real Data from Your Signal Database** 
+
+From your actual Signal contacts (based on christine project extraction):
+
+- **Adia Khan**: +15876643389
+- **Allison Khan**: +14036143389  
+- **Christine Michaels-Igbokwe**: +14035854029
+- **Better ppl of the fam**: Group conversation
+- **Cyberdelia - Personal Disaster**: Group conversation
+- **GitLab Calgary lunch group**: Group conversation
+- And 150+ more contacts and groups
+
+## 🛠 **Database Access Method**
+
+The Signal MCP server uses the same proven approach as your christine project:
+
+1. **Automatic Signal Detection**: Finds Signal installation across platforms
+2. **Key Decryption**: Handles macOS keychain and Linux credential stores
+3. **SQLCipher Integration**: Uses command-line sqlcipher for reliable database access
+4. **Schema Knowledge**: Direct access to conversations, messages, and attachments tables
+
+## 📋 **Schema Structure**
+
+The server understands Signal's database schema:
+
+```sql
+-- Conversations table
+SELECT id, name, profileName, e164, type FROM conversations;
+
+-- Messages table  
+SELECT conversationId, type, json, body, sourceServiceId, sent_at 
+FROM messages 
+WHERE type NOT IN ('keychange', 'profile-change');
+
+-- Rich message data in JSON column includes:
+-- - attachments[]
+-- - reactions[]  
+-- - quote{}
+-- - sticker{}
+```
+
+## 🔐 **Security Features**
+
+- **Read-only access**: No modification of Signal data
+- **Encrypted database support**: Full SQLCipher compatibility
+- **Keychain integration**: Secure key retrieval from system stores
+- **Signal-app-closed requirement**: Prevents database conflicts
+
+## 🎉 **Integration Ready**
+
+Add to your Claude configuration:
+
+```json
+{
+  "mcpServers": {
+    "signal": {
+      "command": "/usr/local/bin/mcp-signal"
+    }
+  }
+}
+```
+
+Then ask Claude things like:
+- "What was my last conversation with Adia?"
+- "Search my Signal messages for 'dinner plans'"  
+- "How many Signal conversations do I have?"
+- "Show me all group conversations"
+
+The Signal MCP server provides the same comprehensive database access as your proven christine project, but exposed through the MCP protocol for seamless AI assistant integration!
\ No newline at end of file