agent-orchestrator-mcp-server 0.2.4 → 0.2.5

package/shared/orchestrator-client/orchestrator-client.integration-mock.js

@@ -443,5 +443,318 @@ export function createIntegrationMockOrchestratorClient(initialMockData) {
                 session_id: session.id,
             };
         },
+        // Session Extensions
+        async forkSession(id, _messageIndex) {
+            const session = mockData.sessions?.find((s) => s.id === Number(id) || s.slug === String(id));
+            if (!session)
+                throw new Error(`API Error (404): Session not found`);
+            sessionIdCounter++;
+            const forked = {
+                ...session,
+                id: sessionIdCounter,
+                title: `Forked: ${session.title}`,
+                status: 'waiting',
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            };
+            mockData.sessions?.push(forked);
+            return { session: forked, message: 'Session forked successfully' };
+        },
+        async refreshSession(id) {
+            const session = mockData.sessions?.find((s) => s.id === Number(id) || s.slug === String(id));
+            if (!session)
+                throw new Error(`API Error (404): Session not found`);
+            return { session, message: 'Session refreshed' };
+        },
+        async refreshAllSessions() {
+            return {
+                message: 'All sessions refreshed',
+                refreshed: mockData.sessions?.length || 0,
+                restarted: 0,
+                continued: 0,
+                errors: 0,
+            };
+        },
+        async updateSessionNotes(id, _notes) {
+            const session = mockData.sessions?.find((s) => s.id === Number(id) || s.slug === String(id));
+            if (!session)
+                throw new Error(`API Error (404): Session not found`);
+            session.updated_at = new Date().toISOString();
+            return session;
+        },
+        async toggleFavorite(id) {
+            const session = mockData.sessions?.find((s) => s.id === Number(id) || s.slug === String(id));
+            if (!session)
+                throw new Error(`API Error (404): Session not found`);
+            return { ...session, favorited: true };
+        },
+        async bulkArchiveSessions(sessionIds) {
+            let archived = 0;
+            for (const sid of sessionIds) {
+                const session = mockData.sessions?.find((s) => s.id === sid);
+                if (session) {
+                    session.status = 'archived';
+                    session.archived_at = new Date().toISOString();
+                    archived++;
+                }
+            }
+            return { archived_count: archived, errors: [] };
+        },
+        async getTranscript(_id, _format) {
+            return { transcript_text: 'User: Hello\nAssistant: Hi there!' };
+        },
+        // Enqueued Messages
+        async listEnqueuedMessages(_sessionId, options) {
+            const page = options?.page || 1;
+            const perPage = options?.per_page || 25;
+            return {
+                enqueued_messages: [],
+                pagination: { page, per_page: perPage, total_count: 0, total_pages: 0 },
+            };
+        },
+        async getEnqueuedMessage(_sessionId, messageId) {
+            return {
+                id: messageId,
+                session_id: 1,
+                content: 'Test message',
+                stop_condition: null,
+                position: 1,
+                status: 'pending',
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            };
+        },
+        async createEnqueuedMessage(sessionId, data) {
+            return {
+                id: 1,
+                session_id: Number(sessionId),
+                content: data.content,
+                stop_condition: data.stop_condition || null,
+                position: 1,
+                status: 'pending',
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            };
+        },
+        async updateEnqueuedMessage(_sessionId, messageId, data) {
+            return {
+                id: messageId,
+                session_id: 1,
+                content: data.content || 'Updated message',
+                stop_condition: data.stop_condition || null,
+                position: 1,
+                status: 'pending',
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            };
+        },
+        async deleteEnqueuedMessage(_sessionId, _messageId) {
+            // No-op
+        },
+        async reorderEnqueuedMessage(_sessionId, messageId, position) {
+            return {
+                id: messageId,
+                session_id: 1,
+                content: 'Test message',
+                stop_condition: null,
+                position,
+                status: 'pending',
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            };
+        },
+        async interruptEnqueuedMessage(sessionId, _messageId) {
+            const session = mockData.sessions?.find((s) => s.id === Number(sessionId) || s.slug === String(sessionId));
+            if (!session)
+                throw new Error(`API Error (404): Session not found`);
+            return { session, message: 'Message sent as interrupt' };
+        },
+        // Triggers
+        async listTriggers(options) {
+            const page = options?.page || 1;
+            const perPage = options?.per_page || 25;
+            return {
+                triggers: [],
+                pagination: { page, per_page: perPage, total_count: 0, total_pages: 0 },
+            };
+        },
+        async getTrigger(id) {
+            const trigger = {
+                id,
+                name: 'Test Trigger',
+                trigger_type: 'schedule',
+                status: 'enabled',
+                agent_root_name: 'mcp-servers',
+                prompt_template: 'Test prompt',
+                stop_condition: null,
+                reuse_session: false,
+                mcp_servers: [],
+                configuration: {},
+                schedule_description: 'Every day',
+                last_session_id: null,
+                last_triggered_at: null,
+                last_polled_at: null,
+                sessions_created_count: 0,
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            };
+            return { trigger, recent_sessions: [] };
+        },
+        async createTrigger(data) {
+            return {
+                id: 1,
+                name: data.name,
+                trigger_type: data.trigger_type,
+                status: data.status || 'enabled',
+                agent_root_name: data.agent_root_name,
+                prompt_template: data.prompt_template,
+                stop_condition: data.stop_condition || null,
+                reuse_session: data.reuse_session || false,
+                mcp_servers: data.mcp_servers || [],
+                configuration: data.configuration || {},
+                schedule_description: null,
+                last_session_id: null,
+                last_triggered_at: null,
+                last_polled_at: null,
+                sessions_created_count: 0,
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            };
+        },
+        async updateTrigger(id, data) {
+            return {
+                id,
+                name: data.name || 'Updated Trigger',
+                trigger_type: data.trigger_type || 'schedule',
+                status: data.status || 'enabled',
+                agent_root_name: data.agent_root_name || 'mcp-servers',
+                prompt_template: data.prompt_template || 'Test prompt',
+                stop_condition: data.stop_condition || null,
+                reuse_session: data.reuse_session || false,
+                mcp_servers: data.mcp_servers || [],
+                configuration: data.configuration || {},
+                schedule_description: null,
+                last_session_id: null,
+                last_triggered_at: null,
+                last_polled_at: null,
+                sessions_created_count: 0,
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            };
+        },
+        async deleteTrigger(_id) {
+            // No-op
+        },
+        async toggleTrigger(id) {
+            return {
+                id,
+                name: 'Toggled Trigger',
+                trigger_type: 'schedule',
+                status: 'disabled',
+                agent_root_name: 'mcp-servers',
+                prompt_template: 'Test prompt',
+                stop_condition: null,
+                reuse_session: false,
+                mcp_servers: [],
+                configuration: {},
+                schedule_description: null,
+                last_session_id: null,
+                last_triggered_at: null,
+                last_polled_at: null,
+                sessions_created_count: 0,
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            };
+        },
+        async getTriggerChannels() {
+            return {
+                channels: [{ id: 'C123', name: 'general', is_private: false, num_members: 50 }],
+            };
+        },
+        // Notification Management
+        async listNotifications(options) {
+            const page = options?.page || 1;
+            const perPage = options?.per_page || 25;
+            return {
+                notifications: [],
+                pagination: { page, per_page: perPage, total_count: 0, total_pages: 0 },
+            };
+        },
+        async getNotification(id) {
+            return {
+                id,
+                session_id: 1,
+                notification_type: 'session_needs_input',
+                read: false,
+                stale: false,
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            };
+        },
+        async getNotificationBadge() {
+            return { pending_count: 0 };
+        },
+        async markNotificationRead(id) {
+            return {
+                id,
+                session_id: 1,
+                notification_type: 'session_needs_input',
+                read: true,
+                stale: false,
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            };
+        },
+        async markAllNotificationsRead() {
+            return { marked_count: 0, pending_count: 0 };
+        },
+        async dismissNotification(_id) {
+            // No-op
+        },
+        async dismissAllReadNotifications() {
+            return { dismissed_count: 0, pending_count: 0 };
+        },
+        // Health
+        async getHealth() {
+            return {
+                health_report: { sessions: { running: 1 } },
+                timestamp: new Date().toISOString(),
+                rails_env: 'test',
+                ruby_version: '3.3.0',
+            };
+        },
+        async cleanupProcesses() {
+            return { cleaned: 0, message: 'No orphaned processes' };
+        },
+        async retrySessions(_sessionIds) {
+            return { retried: 0, message: 'No sessions to retry' };
+        },
+        async archiveOldSessions(_days) {
+            return { archived: 0, message: 'No old sessions' };
+        },
+        // CLIs
+        async getCliStatus() {
+            return { cli_status: {}, unauthenticated_count: 0 };
+        },
+        async refreshCli() {
+            return { queued: true, message: 'CLI refresh queued' };
+        },
+        async clearCliCache() {
+            return { queued: true, message: 'CLI cache clear queued' };
+        },
+        // Transcript Archive
+        async getTranscriptArchiveStatus() {
+            return {
+                generated_at: '2025-01-15T15:00:00Z',
+                session_count: 10,
+                file_size_bytes: 524288,
+            };
+        },
+        getTranscriptArchiveDownloadUrl() {
+            return {
+                url: 'http://localhost:3000/api/v1/transcript_archive/download',
+                apiKey: 'test-api-key',
+            };
+        },
     };
 }

package/shared/orchestrator-client/orchestrator-client.js

@@ -207,4 +207,143 @@ export class AgentOrchestratorClient {
             message,
         });
     }
+    // Session Extensions
+    async forkSession(id, messageIndex) {
+        return this.request('POST', `/sessions/${id}/fork`, {
+            message_index: messageIndex,
+        });
+    }
+    async refreshSession(id) {
+        return this.request('POST', `/sessions/${id}/refresh`);
+    }
+    async refreshAllSessions() {
+        return this.request('POST', '/sessions/refresh_all');
+    }
+    async updateSessionNotes(id, notes) {
+        const response = await this.request('PATCH', `/sessions/${id}/notes`, {
+            session_notes: notes,
+        });
+        return response.session;
+    }
+    async toggleFavorite(id) {
+        return this.request('POST', `/sessions/${id}/toggle_favorite`);
+    }
+    async bulkArchiveSessions(sessionIds) {
+        return this.request('POST', '/sessions/bulk_archive', {
+            session_ids: sessionIds,
+        });
+    }
+    async getTranscript(id, format = 'json') {
+        return this.request('GET', `/sessions/${id}/transcript`, undefined, {
+            format,
+        });
+    }
+    // Enqueued Messages
+    async listEnqueuedMessages(sessionId, options) {
+        return this.request('GET', `/sessions/${sessionId}/enqueued_messages`, undefined, options);
+    }
+    async getEnqueuedMessage(sessionId, messageId) {
+        const response = await this.request('GET', `/sessions/${sessionId}/enqueued_messages/${messageId}`);
+        return response.enqueued_message;
+    }
+    async createEnqueuedMessage(sessionId, data) {
+        const response = await this.request('POST', `/sessions/${sessionId}/enqueued_messages`, data);
+        return response.enqueued_message;
+    }
+    async updateEnqueuedMessage(sessionId, messageId, data) {
+        const response = await this.request('PATCH', `/sessions/${sessionId}/enqueued_messages/${messageId}`, data);
+        return response.enqueued_message;
+    }
+    async deleteEnqueuedMessage(sessionId, messageId) {
+        await this.request('DELETE', `/sessions/${sessionId}/enqueued_messages/${messageId}`);
+    }
+    async reorderEnqueuedMessage(sessionId, messageId, position) {
+        const response = await this.request('PATCH', `/sessions/${sessionId}/enqueued_messages/${messageId}/reorder`, { position });
+        return response.enqueued_message;
+    }
+    async interruptEnqueuedMessage(sessionId, messageId) {
+        return this.request('POST', `/sessions/${sessionId}/enqueued_messages/${messageId}/interrupt`);
+    }
+    // Triggers
+    async listTriggers(options) {
+        return this.request('GET', '/triggers', undefined, options);
+    }
+    async getTrigger(id) {
+        return this.request('GET', `/triggers/${id}`);
+    }
+    async createTrigger(data) {
+        const response = await this.request('POST', '/triggers', data);
+        return response.trigger;
+    }
+    async updateTrigger(id, data) {
+        const response = await this.request('PATCH', `/triggers/${id}`, data);
+        return response.trigger;
+    }
+    async deleteTrigger(id) {
+        await this.request('DELETE', `/triggers/${id}`);
+    }
+    async toggleTrigger(id) {
+        const response = await this.request('POST', `/triggers/${id}/toggle`);
+        return response.trigger;
+    }
+    async getTriggerChannels() {
+        return this.request('GET', '/triggers/channels');
+    }
+    // Notification Management
+    async listNotifications(options) {
+        return this.request('GET', '/notifications', undefined, options);
+    }
+    async getNotification(id) {
+        const response = await this.request('GET', `/notifications/${id}`);
+        return response.notification;
+    }
+    async getNotificationBadge() {
+        return this.request('GET', '/notifications/badge');
+    }
+    async markNotificationRead(id) {
+        const response = await this.request('PATCH', `/notifications/${id}/mark_read`);
+        return response.notification;
+    }
+    async markAllNotificationsRead() {
+        return this.request('PATCH', '/notifications/mark_all_read');
+    }
+    async dismissNotification(id) {
+        await this.request('DELETE', `/notifications/${id}`);
+    }
+    async dismissAllReadNotifications() {
+        return this.request('DELETE', '/notifications/dismiss_all_read');
+    }
+    // Health
+    async getHealth() {
+        return this.request('GET', '/health');
+    }
+    async cleanupProcesses() {
+        return this.request('POST', '/health/cleanup_processes');
+    }
+    async retrySessions(sessionIds) {
+        return this.request('POST', '/health/retry_sessions', sessionIds ? { session_ids: sessionIds } : undefined);
+    }
+    async archiveOldSessions(days) {
+        return this.request('POST', '/health/archive_old', days ? { days } : undefined);
+    }
+    // CLIs
+    async getCliStatus() {
+        return this.request('GET', '/clis/status');
+    }
+    async refreshCli() {
+        return this.request('POST', '/clis/refresh');
+    }
+    async clearCliCache() {
+        return this.request('POST', '/clis/clear_cache');
+    }
+    // Transcript Archive
+    async getTranscriptArchiveStatus() {
+        return this.request('GET', '/transcript_archive/status');
+    }
+    getTranscriptArchiveDownloadUrl() {
+        return {
+            url: `${this.baseUrl}/api/v1/transcript_archive/download`,
+            apiKey: this.apiKey,
+        };
+    }
 }

package/shared/resources.js

@@ -58,7 +58,7 @@ export function createRegisterResources(clientFactory) {
                         AGENT_ORCHESTRATOR_API_KEY: process.env.AGENT_ORCHESTRATOR_API_KEY
                             ? '***configured***'
                             : 'not set',
-                        ENABLED_TOOLGROUPS: process.env.ENABLED_TOOLGROUPS || 'all (default)',
+                        TOOL_GROUPS: process.env.TOOL_GROUPS || 'all (default)',
                         SKIP_HEALTH_CHECKS: process.env.SKIP_HEALTH_CHECKS || 'false',
                     },
                     capabilities: {
@@ -66,9 +66,14 @@ export function createRegisterResources(clientFactory) {
                         resources: true,
                     },
                     toolGroups: {
-                        readonly: 'Read-only operations (list, get, search)',
-                        write: 'Write operations (create, update, follow_up, pause, restart, archive, unarchive)',
-                        admin: 'Administrative operations (delete)',
+                        sessions: 'All session tools (read + write): search, get, configs, start, action, enqueued messages',
+                        sessions_readonly: 'Session tools (read only): search_sessions, get_session, get_configs',
+                        notifications: 'All notification tools (read + write): get, send, mark read, dismiss',
+                        notifications_readonly: 'Notification tools (read only): get_notifications',
+                        triggers: 'All trigger tools (read + write): search, create, update, delete, toggle',
+                        triggers_readonly: 'Trigger tools (read only): search_triggers',
+                        health: 'All health tools (read + write): health report, CLI status, maintenance actions',
+                        health_readonly: 'Health tools (read only): get_system_health',
                     },
                 };
                 return {

package/shared/tools/action-health.d.ts

@@ -0,0 +1,58 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { z } from 'zod';
+import type { IAgentOrchestratorClient } from '../orchestrator-client/orchestrator-client.js';
+export declare const ActionHealthSchema: z.ZodObject<{
+    action: z.ZodEnum<["cleanup_processes", "retry_sessions", "archive_old", "cli_refresh", "cli_clear_cache"]>;
+    session_ids: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+    days: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    action: "cleanup_processes" | "retry_sessions" | "archive_old" | "cli_refresh" | "cli_clear_cache";
+    session_ids?: number[] | undefined;
+    days?: number | undefined;
+}, {
+    action: "cleanup_processes" | "retry_sessions" | "archive_old" | "cli_refresh" | "cli_clear_cache";
+    session_ids?: number[] | undefined;
+    days?: number | undefined;
+}>;
+export declare function actionHealthTool(_server: Server, clientFactory: () => IAgentOrchestratorClient): {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            action: {
+                type: string;
+                enum: readonly ["cleanup_processes", "retry_sessions", "archive_old", "cli_refresh", "cli_clear_cache"];
+                description: string;
+            };
+            session_ids: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            days: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    handler: (args: unknown) => Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+        isError: boolean;
+    } | {
+        content: {
+            type: string;
+            text: string;
+        }[];
+        isError?: undefined;
+    }>;
+};
+//# sourceMappingURL=action-health.d.ts.map

package/shared/tools/action-health.js

@@ -0,0 +1,101 @@
+import { z } from 'zod';
+const ACTION_ENUM = [
+    'cleanup_processes',
+    'retry_sessions',
+    'archive_old',
+    'cli_refresh',
+    'cli_clear_cache',
+];
+export const ActionHealthSchema = z.object({
+    action: z.enum(ACTION_ENUM),
+    session_ids: z.array(z.number()).optional(),
+    days: z.number().min(1).max(365).optional(),
+});
+const TOOL_DESCRIPTION = `Perform system health and maintenance actions.
+
+**Actions:**
+- **cleanup_processes**: Terminate orphaned agent processes
+- **retry_sessions**: Retry failed sessions (optionally specify session_ids)
+- **archive_old**: Archive sessions older than N days (requires "days", default 7)
+- **cli_refresh**: Trigger a background refresh of CLI tool installations
+- **cli_clear_cache**: Clear npm/pip caches and reinstall MCP packages
+
+Note: Health actions are rate-limited (30s cooldown between calls).`;
+export function actionHealthTool(_server, clientFactory) {
+    return {
+        name: 'action_health',
+        description: TOOL_DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                action: { type: 'string', enum: ACTION_ENUM, description: 'Health action to perform.' },
+                session_ids: {
+                    type: 'array',
+                    items: { type: 'number' },
+                    description: 'Session IDs to retry. For retry_sessions action.',
+                },
+                days: {
+                    type: 'number',
+                    minimum: 1,
+                    maximum: 365,
+                    description: 'Archive sessions older than this many days. For archive_old action. Default: 7',
+                },
+            },
+            required: ['action'],
+        },
+        handler: async (args) => {
+            try {
+                const validated = ActionHealthSchema.parse(args);
+                const client = clientFactory();
+                const { action } = validated;
+                let result;
+                switch (action) {
+                    case 'cleanup_processes': {
+                        const response = await client.cleanupProcesses();
+                        result = `## Processes Cleaned Up\n\n\`\`\`json\n${JSON.stringify(response, null, 2)}\n\`\`\``;
+                        break;
+                    }
+                    case 'retry_sessions': {
+                        const response = await client.retrySessions(validated.session_ids);
+                        result = `## Sessions Retried\n\n\`\`\`json\n${JSON.stringify(response, null, 2)}\n\`\`\``;
+                        break;
+                    }
+                    case 'archive_old': {
+                        const response = await client.archiveOldSessions(validated.days);
+                        result = `## Old Sessions Archived\n\n\`\`\`json\n${JSON.stringify(response, null, 2)}\n\`\`\``;
+                        break;
+                    }
+                    case 'cli_refresh': {
+                        const response = await client.refreshCli();
+                        result = `## CLI Refresh Queued\n\n- **Message:** ${response.message}`;
+                        break;
+                    }
+                    case 'cli_clear_cache': {
+                        const response = await client.clearCliCache();
+                        result = `## CLI Cache Clear Queued\n\n- **Message:** ${response.message}`;
+                        break;
+                    }
+                    default: {
+                        const _exhaustiveCheck = action;
+                        return {
+                            content: [{ type: 'text', text: `Error: Unknown action "${_exhaustiveCheck}"` }],
+                            isError: true,
+                        };
+                    }
+                }
+                return { content: [{ type: 'text', text: result }] };
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error performing health action: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        },
+    };
+}