session-collab-mcp 0.5.0 → 0.5.2

package/src/mcp/tools/decision.ts

@@ -3,8 +3,8 @@
 import type { DatabaseAdapter } from '../../db/sqlite-adapter.js';
 import type { McpTool, McpToolResult } from '../protocol';
 import { createToolResult } from '../protocol';
-import type { DecisionCategory } from '../../db/types';
 import { addDecision, listDecisions, getSession } from '../../db/queries';
+import { validateInput, decisionAddSchema, decisionListSchema } from '../schemas';
 
 export const decisionTools: McpTool[] = [
   {
@@ -61,13 +61,17 @@ export async function handleDecisionTool(
 ): Promise<McpToolResult> {
   switch (name) {
     case 'collab_decision_add': {
-      const sessionId = args.session_id as string;
-      const category = args.category as DecisionCategory | undefined;
-      const title = args.title as string;
-      const description = args.description as string;
+      const validation = validateInput(decisionAddSchema, args);
+      if (!validation.success) {
+        return createToolResult(
+          JSON.stringify({ error: 'INVALID_INPUT', message: validation.error }),
+          true
+        );
+      }
+      const input = validation.data;
 
       // Verify session
-      const session = await getSession(db, sessionId);
+      const session = await getSession(db, input.session_id);
       if (!session || session.status !== 'active') {
         return createToolResult(
           JSON.stringify({
@@ -79,10 +83,10 @@ export async function handleDecisionTool(
       }
 
       const decision = await addDecision(db, {
-        session_id: sessionId,
-        category,
-        title,
-        description,
+        session_id: input.session_id,
+        category: input.category,
+        title: input.title,
+        description: input.description,
       });
 
       return createToolResult(
@@ -95,10 +99,19 @@ export async function handleDecisionTool(
     }
 
     case 'collab_decision_list': {
-      const category = args.category as DecisionCategory | undefined;
-      const limit = (args.limit as number) ?? 20;
+      const validation = validateInput(decisionListSchema, args);
+      if (!validation.success) {
+        return createToolResult(
+          JSON.stringify({ error: 'INVALID_INPUT', message: validation.error }),
+          true
+        );
+      }
+      const input = validation.data;
 
-      const decisions = await listDecisions(db, { category, limit });
+      const decisions = await listDecisions(db, {
+        category: input.category,
+        limit: input.limit ?? 20,
+      });
 
       return createToolResult(
         JSON.stringify(

package/src/mcp/tools/lsp.ts

@@ -3,8 +3,15 @@
 import type { DatabaseAdapter } from '../../db/sqlite-adapter.js';
 import type { McpTool, McpToolResult } from '../protocol';
 import { createToolResult } from '../protocol';
-import type { SymbolType, ConflictInfo, ReferenceInput } from '../../db/types';
+import type { SymbolType, ConflictInfo } from '../../db/types';
 import { storeReferences, analyzeClaimImpact, clearSessionReferences } from '../../db/queries';
+import {
+  validateInput,
+  analyzeSymbolsSchema,
+  validateSymbolsSchema,
+  storeReferencesSchema,
+  impactAnalysisSchema,
+} from '../schemas';
 
 // LSP Symbol Kind mapping (from LSP spec)
 const LSP_SYMBOL_KIND_MAP: Record<number, SymbolType> = {
@@ -305,24 +312,17 @@ export async function handleLspTool(
 ): Promise<McpToolResult> {
   switch (name) {
     case 'collab_analyze_symbols': {
-      const sessionId = args.session_id as string;
-      const files = args.files as FileSymbolInput[] | undefined;
-      const references = args.references as SymbolReference[] | undefined;
-      const checkSymbols = args.check_symbols as string[] | undefined;
-
-      if (!sessionId) {
-        return createToolResult(
-          JSON.stringify({ error: 'INVALID_INPUT', message: 'session_id is required' }),
-          true
-        );
-      }
-
-      if (!files || !Array.isArray(files) || files.length === 0) {
+      const validation = validateInput(analyzeSymbolsSchema, args);
+      if (!validation.success) {
         return createToolResult(
-          JSON.stringify({ error: 'INVALID_INPUT', message: 'files array is required' }),
+          JSON.stringify({ error: 'INVALID_INPUT', message: validation.error }),
           true
         );
       }
+      const input = validation.data;
+      const files = input.files as FileSymbolInput[];
+      const references = input.references as SymbolReference[] | undefined;
+      const checkSymbols = input.check_symbols;
 
       // Build reference lookup map if provided
       const referenceMap = new Map<string, SymbolReference>();
@@ -352,10 +352,10 @@ export async function handleLspTool(
       const symbolNames = [...new Set(symbolsToAnalyze.map((s) => s.name))];
 
       // Check for symbol-level claims
-      const symbolConflicts = await querySymbolConflicts(db, fileList, symbolNames, sessionId);
+      const symbolConflicts = await querySymbolConflicts(db, fileList, symbolNames, input.session_id);
 
       // Check for file-level claims
-      const fileConflicts = await queryFileConflicts(db, fileList, sessionId);
+      const fileConflicts = await queryFileConflicts(db, fileList, input.session_id);
 
       // Build result with conflict status for each symbol
       const analyzedSymbols: AnalyzedSymbol[] = [];
@@ -455,23 +455,18 @@ export async function handleLspTool(
     }
 
     case 'collab_validate_symbols': {
-      const file = args.file as string;
-      const symbols = args.symbols as string[];
-      const lspSymbols = args.lsp_symbols as Array<{ name: string; kind: number }>;
-
-      if (!file || !symbols || !lspSymbols) {
+      const validation = validateInput(validateSymbolsSchema, args);
+      if (!validation.success) {
         return createToolResult(
-          JSON.stringify({
-            error: 'INVALID_INPUT',
-            message: 'file, symbols, and lsp_symbols are required',
-          }),
+          JSON.stringify({ error: 'INVALID_INPUT', message: validation.error }),
           true
         );
       }
+      const input = validation.data;
 
       // Build set of available symbol names from LSP data
       const availableSymbols = new Set<string>();
-      for (const lspSym of lspSymbols) {
+      for (const lspSym of input.lsp_symbols) {
         availableSymbols.add(lspSym.name);
       }
 
@@ -480,7 +475,7 @@ export async function handleLspTool(
       const invalid: string[] = [];
       const suggestions: Record<string, string[]> = {};
 
-      for (const sym of symbols) {
+      for (const sym of input.symbols) {
         if (availableSymbols.has(sym)) {
           valid.push(sym);
         } else {
@@ -502,7 +497,7 @@ export async function handleLspTool(
       return createToolResult(
         JSON.stringify({
           valid: allValid,
-          file,
+          file: input.file,
           valid_symbols: valid,
           invalid_symbols: invalid,
           suggestions: Object.keys(suggestions).length > 0 ? suggestions : undefined,
@@ -515,32 +510,23 @@ export async function handleLspTool(
     }
 
     case 'collab_store_references': {
-      const sessionId = args.session_id as string;
-      const references = args.references as ReferenceInput[];
-      const clearExisting = args.clear_existing as boolean | undefined;
-
-      if (!sessionId) {
-        return createToolResult(
-          JSON.stringify({ error: 'INVALID_INPUT', message: 'session_id is required' }),
-          true
-        );
-      }
-
-      if (!references || !Array.isArray(references)) {
+      const validation = validateInput(storeReferencesSchema, args);
+      if (!validation.success) {
         return createToolResult(
-          JSON.stringify({ error: 'INVALID_INPUT', message: 'references array is required' }),
+          JSON.stringify({ error: 'INVALID_INPUT', message: validation.error }),
           true
         );
       }
+      const input = validation.data;
 
       // Clear existing references if requested
       let cleared = 0;
-      if (clearExisting) {
-        cleared = await clearSessionReferences(db, sessionId);
+      if (input.clear_existing) {
+        cleared = await clearSessionReferences(db, input.session_id);
       }
 
       // Store new references
-      const result = await storeReferences(db, sessionId, references);
+      const result = await storeReferences(db, input.session_id, input.references);
 
       return createToolResult(
         JSON.stringify({
@@ -554,21 +540,16 @@ export async function handleLspTool(
     }
 
     case 'collab_impact_analysis': {
-      const sessionId = args.session_id as string;
-      const file = args.file as string;
-      const symbol = args.symbol as string;
-
-      if (!sessionId || !file || !symbol) {
+      const validation = validateInput(impactAnalysisSchema, args);
+      if (!validation.success) {
         return createToolResult(
-          JSON.stringify({
-            error: 'INVALID_INPUT',
-            message: 'session_id, file, and symbol are required',
-          }),
+          JSON.stringify({ error: 'INVALID_INPUT', message: validation.error }),
           true
         );
       }
+      const input = validation.data;
 
-      const impact = await analyzeClaimImpact(db, file, symbol, sessionId);
+      const impact = await analyzeClaimImpact(db, input.file, input.symbol, input.session_id);
 
       // Determine risk level
       let riskLevel: 'low' | 'medium' | 'high';

package/src/mcp/tools/message.ts

@@ -4,6 +4,7 @@ import type { DatabaseAdapter } from '../../db/sqlite-adapter.js';
 import type { McpTool, McpToolResult } from '../protocol';
 import { createToolResult } from '../protocol';
 import { sendMessage, listMessages, getSession } from '../../db/queries';
+import { validateInput, messageSendSchema, messageListSchema } from '../schemas';
 
 export const messageTools: McpTool[] = [
   {
@@ -59,12 +60,17 @@ export async function handleMessageTool(
 ): Promise<McpToolResult> {
   switch (name) {
     case 'collab_message_send': {
-      const fromSessionId = args.from_session_id as string;
-      const toSessionId = args.to_session_id as string | undefined;
-      const content = args.content as string;
+      const validation = validateInput(messageSendSchema, args);
+      if (!validation.success) {
+        return createToolResult(
+          JSON.stringify({ error: 'INVALID_INPUT', message: validation.error }),
+          true
+        );
+      }
+      const input = validation.data;
 
       // Verify sender session
-      const fromSession = await getSession(db, fromSessionId);
+      const fromSession = await getSession(db, input.from_session_id);
       if (!fromSession || fromSession.status !== 'active') {
         return createToolResult(
           JSON.stringify({
@@ -76,8 +82,8 @@ export async function handleMessageTool(
       }
 
       // Verify target session if specified
-      if (toSessionId) {
-        const toSession = await getSession(db, toSessionId);
+      if (input.to_session_id) {
+        const toSession = await getSession(db, input.to_session_id);
         if (!toSession || toSession.status !== 'active') {
           return createToolResult(
             JSON.stringify({
@@ -90,28 +96,36 @@ export async function handleMessageTool(
       }
 
       const message = await sendMessage(db, {
-        from_session_id: fromSessionId,
-        to_session_id: toSessionId,
-        content,
+        from_session_id: input.from_session_id,
+        to_session_id: input.to_session_id,
+        content: input.content,
       });
 
       return createToolResult(
         JSON.stringify({
           success: true,
           message_id: message.id,
-          sent_to: toSessionId ?? 'all sessions (broadcast)',
+          sent_to: input.to_session_id ?? 'all sessions (broadcast)',
           message: 'Message sent successfully.',
         })
       );
     }
 
     case 'collab_message_list': {
-      const sessionId = args.session_id as string;
-      const unreadOnly = (args.unread_only as boolean) ?? true;
-      const markAsRead = (args.mark_as_read as boolean) ?? true;
+      const validation = validateInput(messageListSchema, args);
+      if (!validation.success) {
+        return createToolResult(
+          JSON.stringify({ error: 'INVALID_INPUT', message: validation.error }),
+          true
+        );
+      }
+      const input = validation.data;
+
+      const unreadOnly = input.unread_only ?? true;
+      const markAsRead = input.mark_as_read ?? true;
 
       const messages = await listMessages(db, {
-        session_id: sessionId,
+        session_id: input.session_id,
         unread_only: unreadOnly,
         mark_as_read: markAsRead,
       });

package/src/mcp/tools/session.ts

@@ -14,8 +14,17 @@ import {
   cleanupStaleSessions,
   listClaims,
 } from '../../db/queries';
-import type { TodoItem, SessionConfig, ConflictMode } from '../../db/types';
+import type { TodoItem, SessionConfig } from '../../db/types';
 import { DEFAULT_SESSION_CONFIG } from '../../db/types';
+import {
+  validateInput,
+  sessionStartSchema,
+  sessionEndSchema,
+  sessionListSchema,
+  sessionHeartbeatSchema,
+  statusUpdateSchema,
+  configSchema,
+} from '../schemas';
 
 export const sessionTools: McpTool[] = [
   {
@@ -177,17 +186,26 @@ export async function handleSessionTool(
 ): Promise<McpToolResult> {
   switch (name) {
     case 'collab_session_start': {
+      const validation = validateInput(sessionStartSchema, args);
+      if (!validation.success) {
+        return createToolResult(
+          JSON.stringify({ error: 'INVALID_INPUT', message: validation.error }),
+          true
+        );
+      }
+      const input = validation.data;
+
       // Cleanup stale sessions first
       await cleanupStaleSessions(db, 30);
 
       const session = await createSession(db, {
-        name: args.name as string | undefined,
-        project_root: args.project_root as string,
-        machine_id: args.machine_id as string | undefined,
+        name: input.name,
+        project_root: input.project_root,
+        machine_id: input.machine_id,
         user_id: userId,
       });
 
-      const activeSessions = await listSessions(db, { project_root: args.project_root as string, user_id: userId });
+      const activeSessions = await listSessions(db, { project_root: input.project_root, user_id: userId });
 
       return createToolResult(
         JSON.stringify(
@@ -208,10 +226,16 @@ export async function handleSessionTool(
     }
 
     case 'collab_session_end': {
-      const sessionId = args.session_id as string;
-      const releaseClaims = (args.release_claims as 'complete' | 'abandon') ?? 'abandon';
+      const validation = validateInput(sessionEndSchema, args);
+      if (!validation.success) {
+        return createToolResult(
+          JSON.stringify({ error: 'INVALID_INPUT', message: validation.error }),
+          true
+        );
+      }
+      const input = validation.data;
 
-      const session = await getSession(db, sessionId);
+      const session = await getSession(db, input.session_id);
       if (!session) {
         return createToolResult(
           JSON.stringify({ error: 'SESSION_NOT_FOUND', message: 'Session not found' }),
@@ -219,21 +243,30 @@ export async function handleSessionTool(
         );
       }
 
-      await endSession(db, sessionId, releaseClaims);
+      await endSession(db, input.session_id, input.release_claims);
 
       return createToolResult(
         JSON.stringify({
           success: true,
-          message: `Session ended. All claims marked as ${releaseClaims === 'complete' ? 'completed' : 'abandoned'}.`,
+          message: `Session ended. All claims marked as ${input.release_claims === 'complete' ? 'completed' : 'abandoned'}.`,
         })
       );
     }
 
     case 'collab_session_list': {
+      const validation = validateInput(sessionListSchema, args);
+      if (!validation.success) {
+        return createToolResult(
+          JSON.stringify({ error: 'INVALID_INPUT', message: validation.error }),
+          true
+        );
+      }
+      const input = validation.data;
+
       // Do not filter by user_id - collaboration tool should show all sessions
       const sessions = await listSessions(db, {
-        include_inactive: args.include_inactive as boolean,
-        project_root: args.project_root as string | undefined,
+        include_inactive: input.include_inactive,
+        project_root: input.project_root,
       });
 
       // Get active claims count for each session and include status info
@@ -278,13 +311,18 @@ export async function handleSessionTool(
     }
 
     case 'collab_session_heartbeat': {
-      const sessionId = args.session_id as string;
-      const currentTask = args.current_task as string | undefined;
-      const todos = args.todos as TodoItem[] | undefined;
+      const validation = validateInput(sessionHeartbeatSchema, args);
+      if (!validation.success) {
+        return createToolResult(
+          JSON.stringify({ error: 'INVALID_INPUT', message: validation.error }),
+          true
+        );
+      }
+      const input = validation.data;
 
-      const updated = await updateSessionHeartbeat(db, sessionId, {
-        current_task: currentTask,
-        todos,
+      const updated = await updateSessionHeartbeat(db, input.session_id, {
+        current_task: input.current_task,
+        todos: input.todos as TodoItem[] | undefined,
       });
 
       if (!updated) {
@@ -301,18 +339,24 @@ export async function handleSessionTool(
         JSON.stringify({
           success: true,
           message: 'Heartbeat updated',
-          status_synced: !!(currentTask || todos),
+          status_synced: !!(input.current_task || input.todos),
         })
       );
     }
 
     case 'collab_status_update': {
-      const sessionId = args.session_id as string;
-      const currentTask = args.current_task as string | undefined;
-      const todos = args.todos as TodoItem[] | undefined;
+      const validation = validateInput(statusUpdateSchema, args);
+      if (!validation.success) {
+        return createToolResult(
+          JSON.stringify({ error: 'INVALID_INPUT', message: validation.error }),
+          true
+        );
+      }
+      const input = validation.data;
+      const todos = input.todos as TodoItem[] | undefined;
 
       // Validate session exists
-      const session = await getSession(db, sessionId);
+      const session = await getSession(db, input.session_id);
       if (!session || session.status !== 'active') {
         return createToolResult(
           JSON.stringify({
@@ -323,8 +367,8 @@ export async function handleSessionTool(
         );
       }
 
-      await updateSessionStatus(db, sessionId, {
-        current_task: currentTask,
+      await updateSessionStatus(db, input.session_id, {
+        current_task: input.current_task,
         todos,
       });
 
@@ -343,28 +387,24 @@ export async function handleSessionTool(
         JSON.stringify({
           success: true,
           message: 'Status updated successfully.',
-          current_task: currentTask ?? null,
+          current_task: input.current_task ?? null,
           progress,
         })
       );
     }
 
     case 'collab_config': {
-      const sessionId = args.session_id as string;
-
-      // Validate session_id input
-      if (!sessionId || typeof sessionId !== 'string') {
+      const validation = validateInput(configSchema, args);
+      if (!validation.success) {
         return createToolResult(
-          JSON.stringify({
-            error: 'INVALID_INPUT',
-            message: 'session_id is required',
-          }),
+          JSON.stringify({ error: 'INVALID_INPUT', message: validation.error }),
           true
         );
       }
+      const input = validation.data;
 
       // Validate session exists
-      const session = await getSession(db, sessionId);
+      const session = await getSession(db, input.session_id);
       if (!session || session.status !== 'active') {
         return createToolResult(
           JSON.stringify({
@@ -387,17 +427,17 @@ export async function handleSessionTool(
 
       // Update with new values
       const newConfig: SessionConfig = {
-        mode: (args.mode as ConflictMode) ?? currentConfig.mode,
-        allow_release_others: args.allow_release_others !== undefined
-          ? (args.allow_release_others as boolean)
+        mode: input.mode ?? currentConfig.mode,
+        allow_release_others: input.allow_release_others !== undefined
+          ? input.allow_release_others
           : currentConfig.allow_release_others,
-        auto_release_stale: args.auto_release_stale !== undefined
-          ? (args.auto_release_stale as boolean)
+        auto_release_stale: input.auto_release_stale !== undefined
+          ? input.auto_release_stale
           : currentConfig.auto_release_stale,
-        stale_threshold_hours: (args.stale_threshold_hours as number) ?? currentConfig.stale_threshold_hours,
+        stale_threshold_hours: input.stale_threshold_hours ?? currentConfig.stale_threshold_hours,
       };
 
-      await updateSessionConfig(db, sessionId, newConfig);
+      await updateSessionConfig(db, input.session_id, newConfig);
 
       return createToolResult(
         JSON.stringify({