@prmichaelsen/task-mcp 0.2.0

package/firestore.rules

@@ -0,0 +1,95 @@
+rules_version = '2';
+
+service cloud.firestore {
+  match /databases/{database}/documents {
+    
+    // Helper function to check if user is authenticated
+    function isAuthenticated() {
+      return request.auth != null;
+    }
+    
+    // Helper function to check if user owns the resource
+    function isOwner(userId) {
+      return isAuthenticated() && request.auth.uid == userId;
+    }
+    
+    // Helper function to validate task structure
+    function isValidTask() {
+      let task = request.resource.data;
+      return task.keys().hasAll(['id', 'user_id', 'title', 'description', 'status', 
+                                  'created_at', 'updated_at', 'progress', 'execution', 'config'])
+        && task.status in ['not_started', 'in_progress', 'paused', 'completed', 'failed']
+        && task.user_id is string
+        && task.title is string
+        && task.description is string;
+    }
+    
+    // Helper function to validate task message structure
+    function isValidTaskMessage() {
+      let message = request.resource.data;
+      return message.keys().hasAll(['task_id', 'role', 'content', 'timestamp'])
+        && message.role in ['user', 'assistant', 'system']
+        && message.task_id is string
+        && message.content is string
+        && message.timestamp is string;
+    }
+    
+    // User tasks collection
+    // Path: users/{userId}/tasks/{taskId}
+    match /users/{userId}/tasks/{taskId} {
+      // Allow read if user owns the task
+      allow read: if isOwner(userId);
+      
+      // Allow create if user is authenticated and owns the task
+      allow create: if isOwner(userId) 
+                    && isValidTask()
+                    && request.resource.data.user_id == userId;
+      
+      // Allow update if user owns the task and user_id doesn't change
+      allow update: if isOwner(userId)
+                    && isValidTask()
+                    && request.resource.data.user_id == resource.data.user_id;
+      
+      // Allow delete if user owns the task
+      allow delete: if isOwner(userId);
+      
+      // Task messages subcollection
+      // Path: users/{userId}/tasks/{taskId}/messages/{messageId}
+      match /messages/{messageId} {
+        // Allow read if user owns the parent task
+        allow read: if isOwner(userId);
+        
+        // Allow create if user owns the parent task and message is valid
+        allow create: if isOwner(userId)
+                      && isValidTaskMessage()
+                      && request.resource.data.task_id == taskId;
+        
+        // Allow update if user owns the parent task
+        allow update: if isOwner(userId)
+                      && isValidTaskMessage()
+                      && request.resource.data.task_id == resource.data.task_id;
+        
+        // Allow delete if user owns the parent task
+        allow delete: if isOwner(userId);
+      }
+    }
+    
+    // Task events collection (for WebSocket updates)
+    // Path: users/{userId}/task_events/{eventId}
+    match /users/{userId}/task_events/{eventId} {
+      // Allow read if user owns the events
+      allow read: if isOwner(userId);
+      
+      // Allow create if user is authenticated (system can create events)
+      allow create: if isAuthenticated();
+      
+      // Deny updates and deletes (events are immutable)
+      allow update, delete: if false;
+    }
+    
+    // Deny all other access
+    match /{document=**} {
+      allow read, write: if false;
+    }
+  }
+}

package/jest.config.js

@@ -0,0 +1,31 @@
+export default {
+  preset: 'ts-jest/presets/default-esm',
+  testEnvironment: 'node',
+  extensionsToTreatAsEsm: ['.ts'],
+  roots: ['<rootDir>/src'],
+  testMatch: ['**/*.spec.ts'],
+  moduleFileExtensions: ['ts', 'js'],
+  collectCoverage: true,
+  coverageDirectory: 'coverage',
+  coverageReporters: ['text', 'lcov', 'html'],
+  collectCoverageFrom: [
+    'src/**/*.ts',
+    '!src/**/*.d.ts',
+    '!src/**/*.spec.ts',
+    '!src/**/*.e2e.ts',
+    '!src/test-schemas.ts',
+  ],
+  moduleNameMapper: {
+    '^@/(.*)\\.(js|ts)$': '<rootDir>/src/$1',
+    '^@/(.*)$': '<rootDir>/src/$1',
+    '^(\\.{1,2}/.*)\\.js$': '$1',
+  },
+  transform: {
+    '^.+\\.ts$': [
+      'ts-jest',
+      {
+        useESM: true,
+      },
+    ],
+  },
+};

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@prmichaelsen/task-mcp",
+  "version": "0.2.0",
+  "description": "MCP server for autonomous task execution with ACP-style task management",
+  "type": "module",
+  "main": "dist/server.js",
+  "bin": {
+    "task-mcp": "./dist/server.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js"
+    },
+    "./factory": {
+      "types": "./dist/server-factory.d.ts",
+      "import": "./dist/server-factory.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.js"
+    },
+    "./services": {
+      "types": "./dist/services/task-database.service.d.ts",
+      "import": "./dist/services/task-database.service.js"
+    },
+    "./schemas": {
+      "types": "./dist/schemas/task.d.ts",
+      "import": "./dist/schemas/task.js"
+    },
+    "./dto": {
+      "types": "./dist/dto/index.d.ts",
+      "import": "./dist/dto/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "test:unit": "jest --testMatch='**/*.spec.ts'",
+    "test:e2e": "jest --testMatch='**/*.e2e.ts'",
+    "test:schemas": "tsx src/test-schemas.ts",
+    "test:all": "npm run test:unit && npm run test:e2e",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "mcp",
+    "task-execution",
+    "autonomous",
+    "acp",
+    "firestore"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "firebase-admin": "^13.6.1",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/node": "^25.2.3",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.4.6",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  }
+}

package/src/client.spec.ts

@@ -0,0 +1,199 @@
+/**
+ * Unit Tests for FirebaseClient
+ */
+
+import { describe, it, expect, jest, beforeEach, afterEach } from '@jest/globals'
+import { FirebaseClient } from '@/client.js'
+import * as firebaseApp from 'firebase-admin/app'
+import * as firebaseFirestore from 'firebase-admin/firestore'
+import { TaskDatabaseService } from '@/services/task-database.service.js'
+
+// Mock Firebase Admin
+jest.mock('firebase-admin/app')
+jest.mock('firebase-admin/firestore')
+jest.mock('@/services/task-database.service.js')
+
+describe('FirebaseClient', () => {
+  const mockUserId = 'test-user-123'
+  const mockServiceAccountPath = './test-service-account.json'
+  
+  let client: FirebaseClient
+  let mockApp: any
+  let mockDb: any
+
+  beforeEach(() => {
+    // Setup mocks
+    mockApp = { name: `task-mcp-${mockUserId}` }
+    mockDb = {}
+    
+    ;(firebaseApp.getApps as jest.Mock<any>).mockReturnValue([])
+    ;(firebaseApp.initializeApp as jest.Mock<any>).mockReturnValue(mockApp)
+    ;(firebaseApp.cert as jest.Mock<any>).mockReturnValue({})
+    ;(firebaseFirestore.getFirestore as jest.Mock<any>).mockReturnValue(mockDb)
+    ;(TaskDatabaseService.initialize as jest.Mock<any>).mockReturnValue(undefined)
+  })
+
+  afterEach(() => {
+    jest.clearAllMocks()
+  })
+
+  describe('Constructor', () => {
+    it('should create client with userId', () => {
+      client = new FirebaseClient({
+        userId: mockUserId,
+        serviceAccountPath: mockServiceAccountPath
+      })
+      
+      expect(client).toBeDefined()
+    })
+
+    it('should throw error if userId is missing', () => {
+      expect(() => {
+        new FirebaseClient({
+          userId: '',
+          serviceAccountPath: mockServiceAccountPath
+        })
+      }).toThrow('userId is required')
+    })
+  })
+
+  describe('connect', () => {
+    it('should initialize Firebase with service account path', async () => {
+      client = new FirebaseClient({
+        userId: mockUserId,
+        serviceAccountPath: mockServiceAccountPath
+      })
+      
+      await client.connect()
+      
+      expect(firebaseApp.cert).toHaveBeenCalledWith(mockServiceAccountPath)
+      expect(firebaseApp.initializeApp).toHaveBeenCalled()
+      expect(firebaseFirestore.getFirestore).toHaveBeenCalledWith(mockApp)
+      expect(TaskDatabaseService.initialize).toHaveBeenCalledWith(mockDb)
+    })
+
+    it('should initialize Firebase with service account JSON', async () => {
+      const mockServiceAccount = { type: 'service_account', project_id: 'test' }
+      
+      client = new FirebaseClient({
+        userId: mockUserId,
+        serviceAccountJson: JSON.stringify(mockServiceAccount)
+      })
+      
+      await client.connect()
+      
+      expect(firebaseApp.cert).toHaveBeenCalledWith(mockServiceAccount)
+      expect(firebaseApp.initializeApp).toHaveBeenCalled()
+    })
+
+    it('should reuse existing app if already initialized', async () => {
+      const existingApp = { name: `task-mcp-${mockUserId}` }
+      ;(firebaseApp.getApps as jest.Mock<any>).mockReturnValue([existingApp])
+      
+      client = new FirebaseClient({
+        userId: mockUserId,
+        serviceAccountPath: mockServiceAccountPath
+      })
+      
+      await client.connect()
+      
+      expect(firebaseApp.initializeApp).not.toHaveBeenCalled()
+      expect(firebaseFirestore.getFirestore).toHaveBeenCalledWith(existingApp)
+    })
+
+    it('should not reconnect if already connected', async () => {
+      client = new FirebaseClient({
+        userId: mockUserId,
+        serviceAccountPath: mockServiceAccountPath
+      })
+      
+      await client.connect()
+      await client.connect() // Second call
+      
+      expect(firebaseApp.initializeApp).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('disconnect', () => {
+    it('should delete app and cleanup', async () => {
+      ;(firebaseApp.deleteApp as jest.Mock<any>).mockResolvedValue(undefined)
+      
+      client = new FirebaseClient({
+        userId: mockUserId,
+        serviceAccountPath: mockServiceAccountPath
+      })
+      
+      await client.connect()
+      await client.disconnect()
+      
+      expect(firebaseApp.deleteApp).toHaveBeenCalledWith(mockApp)
+      expect(client.isConnected()).toBe(false)
+    })
+  })
+
+  describe('Task Operations', () => {
+    beforeEach(async () => {
+      client = new FirebaseClient({
+        userId: mockUserId,
+        serviceAccountPath: mockServiceAccountPath
+      })
+      await client.connect()
+    })
+
+    it('should get task', async () => {
+      const mockTask = { id: 'task-123', title: 'Test Task' } as any
+      ;(TaskDatabaseService.getTask as jest.Mock<any>).mockResolvedValue(mockTask)
+      
+      const task = await client.getTask('task-123')
+      
+      expect(TaskDatabaseService.getTask).toHaveBeenCalledWith(mockUserId, 'task-123')
+      expect(task).toEqual(mockTask)
+    })
+
+    it('should create task', async () => {
+      const mockTask = { id: 'task-456', title: 'New Task' } as any
+      ;(TaskDatabaseService.createTask as jest.Mock<any>).mockResolvedValue(mockTask)
+      
+      const task = await client.createTask('New Task', 'Description')
+      
+      expect(TaskDatabaseService.createTask).toHaveBeenCalledWith(
+        mockUserId,
+        'New Task',
+        'Description',
+        undefined,
+        undefined
+      )
+      expect(task).toEqual(mockTask)
+    })
+
+    it('should update task status', async () => {
+      ;(TaskDatabaseService.updateTaskStatus as jest.Mock<any>).mockResolvedValue(undefined)
+      
+      await client.updateTaskStatus('task-123', 'in_progress')
+      
+      expect(TaskDatabaseService.updateTaskStatus).toHaveBeenCalledWith(
+        mockUserId,
+        'task-123',
+        'in_progress'
+      )
+    })
+  })
+
+  describe('Auto-connect', () => {
+    it('should auto-connect when calling methods if not connected', async () => {
+      client = new FirebaseClient({
+        userId: mockUserId,
+        serviceAccountPath: mockServiceAccountPath
+      })
+      
+      ;(TaskDatabaseService.getTask as jest.Mock<any>).mockResolvedValue(null)
+      
+      // Don't call connect() manually
+      await client.getTask('task-123')
+      
+      // Should have auto-connected
+      expect(firebaseApp.initializeApp).toHaveBeenCalled()
+      expect(client.isConnected()).toBe(true)
+    })
+  })
+})

package/src/client.ts

@@ -0,0 +1,315 @@
+/**
+ * Firebase Client Wrapper
+ * 
+ * Provides a clean interface for MCP tools to interact with Firestore.
+ * Handles service account authentication and user-scoped operations.
+ */
+
+import { initializeApp, cert, App, getApps, deleteApp } from 'firebase-admin/app'
+import { getFirestore, Firestore } from 'firebase-admin/firestore'
+import { TaskDatabaseService } from '@/services/task-database.service.js'
+import type { Task, Milestone, TaskItem } from '@/schemas/task.js'
+
+export interface FirebaseClientConfig {
+  userId: string
+  serviceAccountPath?: string
+  serviceAccountJson?: string
+  projectId?: string
+}
+
+export class FirebaseClient {
+  private app: App | null = null
+  private db: Firestore | null = null
+  private userId: string
+  private config: FirebaseClientConfig
+
+  constructor(config: FirebaseClientConfig) {
+    if (!config.userId) {
+      throw new Error('userId is required')
+    }
+    
+    this.userId = config.userId
+    this.config = config
+  }
+
+  /**
+   * Initialize Firebase connection
+   */
+  async connect(): Promise<void> {
+    if (this.app) {
+      return // Already connected
+    }
+
+    try {
+      // Check if already initialized
+      const existingApps = getApps()
+      const appName = `task-mcp-${this.userId}`
+      const existingApp = existingApps.find(app => app.name === appName)
+      
+      if (existingApp) {
+        this.app = existingApp
+        this.db = getFirestore(this.app)
+        TaskDatabaseService.initialize(this.db)
+        return
+      }
+
+      // Get service account credentials
+      let credential
+      
+      if (this.config.serviceAccountJson) {
+        // Use JSON string
+        const serviceAccount = JSON.parse(this.config.serviceAccountJson)
+        credential = cert(serviceAccount)
+      } else if (this.config.serviceAccountPath) {
+        // Use file path
+        credential = cert(this.config.serviceAccountPath)
+      } else if (process.env.FIREBASE_SERVICE_ACCOUNT_JSON) {
+        // From environment variable (JSON)
+        const serviceAccount = JSON.parse(process.env.FIREBASE_SERVICE_ACCOUNT_JSON)
+        credential = cert(serviceAccount)
+      } else if (process.env.FIREBASE_SERVICE_ACCOUNT_PATH) {
+        // From environment variable (path)
+        credential = cert(process.env.FIREBASE_SERVICE_ACCOUNT_PATH)
+      } else {
+        throw new Error('Firebase service account credentials required')
+      }
+
+      // Initialize app
+      this.app = initializeApp(
+        {
+          credential,
+          projectId: this.config.projectId || process.env.FIREBASE_PROJECT_ID
+        },
+        appName
+      )
+
+      this.db = getFirestore(this.app)
+      TaskDatabaseService.initialize(this.db)
+    } catch (error) {
+      throw new Error(`Failed to initialize Firebase: ${error instanceof Error ? error.message : String(error)}`)
+    }
+  }
+
+  /**
+   * Disconnect and cleanup
+   */
+  async disconnect(): Promise<void> {
+    if (this.app) {
+      await deleteApp(this.app)
+      this.app = null
+      this.db = null
+    }
+  }
+
+  /**
+   * Check if connected
+   */
+  isConnected(): boolean {
+    return this.app !== null && this.db !== null
+  }
+
+  // ==================== Task Operations ====================
+
+  /**
+   * Get a task (user-scoped)
+   */
+  async getTask(taskId: string): Promise<Task | null> {
+    if (!this.isConnected()) {
+      await this.connect()
+    }
+    return TaskDatabaseService.getTask(this.userId, taskId)
+  }
+
+  /**
+   * Create a task (user-scoped)
+   */
+  async createTask(
+    title: string,
+    description: string,
+    config?: Partial<Task['config']>,
+    metadata?: Task['metadata']
+  ): Promise<Task> {
+    if (!this.isConnected()) {
+      await this.connect()
+    }
+    return TaskDatabaseService.createTask(this.userId, title, description, config, metadata)
+  }
+
+  /**
+   * Update task status (user-scoped)
+   */
+  async updateTaskStatus(taskId: string, status: Task['status']): Promise<void> {
+    if (!this.isConnected()) {
+      await this.connect()
+    }
+    return TaskDatabaseService.updateTaskStatus(this.userId, taskId, status)
+  }
+
+  /**
+   * Delete a task (user-scoped)
+   */
+  async deleteTask(taskId: string): Promise<void> {
+    if (!this.isConnected()) {
+      await this.connect()
+    }
+    return TaskDatabaseService.deleteTask(this.userId, taskId)
+  }
+
+  /**
+   * List tasks (user-scoped)
+   */
+  async listTasks(limit = 50): Promise<Task[]> {
+    if (!this.isConnected()) {
+      await this.connect()
+    }
+    return TaskDatabaseService.listTasks(this.userId, limit)
+  }
+
+  // ==================== Progress Operations ====================
+
+  /**
+   * Update overall progress (user-scoped)
+   */
+  async updateOverallProgress(taskId: string, percentage: number): Promise<void> {
+    if (!this.isConnected()) {
+      await this.connect()
+    }
+    return TaskDatabaseService.updateOverallProgress(this.userId, taskId, percentage)
+  }
+
+  /**
+   * Create a milestone (user-scoped)
+   */
+  async createMilestone(taskId: string, milestone: Milestone): Promise<void> {
+    if (!this.isConnected()) {
+      await this.connect()
+    }
+    return TaskDatabaseService.createMilestone(this.userId, taskId, milestone)
+  }
+
+  /**
+   * Update a milestone (user-scoped)
+   */
+  async updateMilestone(
+    taskId: string,
+    milestoneId: string,
+    updates: Partial<Milestone>
+  ): Promise<void> {
+    if (!this.isConnected()) {
+      await this.connect()
+    }
+    return TaskDatabaseService.updateMilestone(this.userId, taskId, milestoneId, updates)
+  }
+
+  /**
+   * Complete a milestone (user-scoped)
+   */
+  async completeMilestone(taskId: string, milestoneId: string): Promise<void> {
+    if (!this.isConnected()) {
+      await this.connect()
+    }
+    return TaskDatabaseService.completeMilestone(this.userId, taskId, milestoneId)
+  }
+
+  /**
+   * Create a task item (user-scoped)
+   */
+  async createTaskItem(
+    taskId: string,
+    milestoneId: string,
+    taskItem: TaskItem
+  ): Promise<void> {
+    if (!this.isConnected()) {
+      await this.connect()
+    }
+    return TaskDatabaseService.createTaskItem(this.userId, taskId, milestoneId, taskItem)
+  }
+
+  /**
+   * Update a task item (user-scoped)
+   */
+  async updateTaskItem(
+    taskId: string,
+    milestoneId: string,
+    taskItemId: string,
+    updates: Partial<TaskItem>
+  ): Promise<void> {
+    if (!this.isConnected()) {
+      await this.connect()
+    }
+    return TaskDatabaseService.updateTaskItem(this.userId, taskId, milestoneId, taskItemId, updates)
+  }
+
+  /**
+   * Complete a task item (user-scoped)
+   */
+  async completeTaskItem(
+    taskId: string,
+    milestoneId: string,
+    taskItemId: string
+  ): Promise<void> {
+    if (!this.isConnected()) {
+      await this.connect()
+    }
+    return TaskDatabaseService.completeTaskItem(this.userId, taskId, milestoneId, taskItemId)
+  }
+
+  // ==================== Message Operations ====================
+
+  /**
+   * Add a message (user-scoped)
+   */
+  async addMessage(
+    taskId: string,
+    role: 'user' | 'assistant' | 'system',
+    content: string,
+    metadata?: any
+  ): Promise<string> {
+    if (!this.isConnected()) {
+      await this.connect()
+    }
+    return TaskDatabaseService.addMessage(this.userId, taskId, role, content, metadata)
+  }
+
+  /**
+   * Get messages (user-scoped)
+   */
+  async getMessages(taskId: string, limit = 100): Promise<any[]> {
+    if (!this.isConnected()) {
+      await this.connect()
+    }
+    return TaskDatabaseService.getMessages(this.userId, taskId, limit)
+  }
+
+  // ==================== Query Operations ====================
+
+  /**
+   * Get tasks by status (user-scoped)
+   */
+  async getTasksByStatus(status: Task['status'], limit = 50): Promise<Task[]> {
+    if (!this.isConnected()) {
+      await this.connect()
+    }
+    return TaskDatabaseService.getTasksByStatus(this.userId, status, limit)
+  }
+
+  /**
+   * Get active tasks (user-scoped)
+   */
+  async getActiveTasks(limit = 50): Promise<Task[]> {
+    if (!this.isConnected()) {
+      await this.connect()
+    }
+    return TaskDatabaseService.getActiveTasks(this.userId, limit)
+  }
+
+  /**
+   * Search tasks by title (user-scoped)
+   */
+  async searchTasksByTitle(searchTerm: string, limit = 50): Promise<Task[]> {
+    if (!this.isConnected()) {
+      await this.connect()
+    }
+    return TaskDatabaseService.searchTasksByTitle(this.userId, searchTerm, limit)
+  }
+}