agent-orchestrator-mcp-server 0.2.3 → 0.2.5

package/shared/tools.js

@@ -1,51 +1,122 @@
 import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-// Simplified tool surface - 6 tools
+// 13 tools across 4 domains
 import { searchSessionsTool } from './tools/search-sessions.js';
 import { startSessionTool } from './tools/start-session.js';
 import { getSessionTool } from './tools/get-session.js';
 import { actionSessionTool } from './tools/action-session.js';
 import { getConfigsTool } from './tools/get-configs.js';
+import { manageEnqueuedMessagesTool } from './tools/manage-enqueued-messages.js';
 import { sendPushNotificationTool } from './tools/send-push-notification.js';
-const ALL_TOOL_GROUPS = ['readonly', 'write', 'admin'];
+import { getNotificationsTool } from './tools/get-notifications.js';
+import { actionNotificationTool } from './tools/action-notification.js';
+import { searchTriggersTool } from './tools/search-triggers.js';
+import { actionTriggerTool } from './tools/action-trigger.js';
+import { getSystemHealthTool } from './tools/get-system-health.js';
+import { actionHealthTool } from './tools/action-health.js';
+import { getTranscriptArchiveTool } from './tools/get-transcript-archive.js';
 /**
- * Parse enabled tool groups from environment variable.
- * @param enabledGroupsParam - Comma-separated list of groups (e.g., "readonly,write")
+ * All valid tool groups (base groups and their _readonly variants)
+ */
+const VALID_TOOL_GROUPS = [
+    'sessions',
+    'sessions_readonly',
+    'notifications',
+    'notifications_readonly',
+    'triggers',
+    'triggers_readonly',
+    'health',
+    'health_readonly',
+];
+/**
+ * Base groups (without _readonly suffix) - used for default "all groups" behavior
+ */
+const BASE_TOOL_GROUPS = ['sessions', 'notifications', 'triggers', 'health'];
+/**
+ * Parse enabled tool groups from environment variable or parameter.
+ * @param enabledGroupsParam - Comma-separated list of groups (e.g., "sessions,notifications")
  * @returns Array of enabled tool groups
  */
 export function parseEnabledToolGroups(enabledGroupsParam) {
-    if (!enabledGroupsParam) {
-        return ALL_TOOL_GROUPS; // All groups enabled by default
+    const groupsStr = enabledGroupsParam || process.env.TOOL_GROUPS || '';
+    if (!groupsStr) {
+        // Default: all base groups enabled (full read+write access)
+        return [...BASE_TOOL_GROUPS];
     }
-    const requestedGroups = enabledGroupsParam.split(',').map((g) => g.trim().toLowerCase());
-    const validGroups = requestedGroups.filter((g) => ALL_TOOL_GROUPS.includes(g));
-    if (validGroups.length === 0) {
-        console.error(`Warning: No valid tool groups found in "${enabledGroupsParam}". Valid groups: ${ALL_TOOL_GROUPS.join(', ')}`);
-        return ALL_TOOL_GROUPS;
+    const groups = groupsStr.split(',').map((g) => g.trim());
+    const validGroups = [];
+    for (const group of groups) {
+        if (VALID_TOOL_GROUPS.includes(group) &&
+            !validGroups.includes(group)) {
+            validGroups.push(group);
+        }
+        else if (!VALID_TOOL_GROUPS.includes(group)) {
+            console.warn(`Unknown tool group: ${group}`);
+        }
     }
     return validGroups;
 }
 /**
  * All available tools with their group assignments.
- * Tools can belong to multiple groups.
  *
- * Simplified tool surface:
- * - search_sessions: Search/list/get sessions by ID
- * - start_session: Create a new session
- * - get_session: Get detailed session info with optional logs/transcripts
- * - action_session: Perform actions (follow_up, pause, restart, archive, unarchive)
- * - get_configs: Fetch all static configuration (MCP servers, agent roots, stop conditions)
- * - send_push_notification: Send a push notification about a session needing attention
+ * 14 tools across 4 domains:
+ * - search_sessions: Search/list/get sessions by ID (sessions, read)
+ * - get_session: Get detailed session info with optional logs/transcripts (sessions, read)
+ * - get_configs: Fetch all static configuration (sessions, read)
+ * - get_transcript_archive: Get transcript archive download URL and metadata (sessions, read)
+ * - start_session: Create a new session (sessions, write)
+ * - action_session: Perform session actions (sessions, write)
+ * - manage_enqueued_messages: Manage session message queue (sessions, write)
+ * - get_notifications: Get/list notifications and badge count (notifications, read)
+ * - send_push_notification: Send a push notification (notifications, write)
+ * - action_notification: Mark read, dismiss notifications (notifications, write)
+ * - search_triggers: Search/list automation triggers (triggers, read)
+ * - action_trigger: Create, update, delete, toggle triggers (triggers, write)
+ * - get_system_health: Get system health report and CLI status (health, read)
+ * - action_health: System maintenance actions (health, write)
  */
 const ALL_TOOLS = [
-    // Read operations
-    { factory: searchSessionsTool, groups: ['readonly', 'write', 'admin'] },
-    { factory: getSessionTool, groups: ['readonly', 'write', 'admin'] },
-    { factory: getConfigsTool, groups: ['readonly', 'write', 'admin'] },
-    // Write operations
-    { factory: startSessionTool, groups: ['write', 'admin'] },
-    { factory: actionSessionTool, groups: ['write', 'admin'] },
-    { factory: sendPushNotificationTool, groups: ['write', 'admin'] },
+    // Session tools - read operations
+    { factory: searchSessionsTool, group: 'sessions', isWriteOperation: false },
+    { factory: getSessionTool, group: 'sessions', isWriteOperation: false },
+    { factory: getConfigsTool, group: 'sessions', isWriteOperation: false },
+    { factory: getTranscriptArchiveTool, group: 'sessions', isWriteOperation: false },
+    // Session tools - write operations
+    { factory: startSessionTool, group: 'sessions', isWriteOperation: true },
+    { factory: actionSessionTool, group: 'sessions', isWriteOperation: true },
+    { factory: manageEnqueuedMessagesTool, group: 'sessions', isWriteOperation: true },
+    // Notification tools - read operations
+    { factory: getNotificationsTool, group: 'notifications', isWriteOperation: false },
+    // Notification tools - write operations
+    { factory: sendPushNotificationTool, group: 'notifications', isWriteOperation: true },
+    { factory: actionNotificationTool, group: 'notifications', isWriteOperation: true },
+    // Trigger tools - read operations
+    { factory: searchTriggersTool, group: 'triggers', isWriteOperation: false },
+    // Trigger tools - write operations
+    { factory: actionTriggerTool, group: 'triggers', isWriteOperation: true },
+    // Health tools - read operations
+    { factory: getSystemHealthTool, group: 'health', isWriteOperation: false },
+    // Health tools - write operations
+    { factory: actionHealthTool, group: 'health', isWriteOperation: true },
 ];
+/**
+ * Check if a tool should be included based on enabled groups.
+ * @param toolDef - The tool definition to check
+ * @param enabledGroups - Array of enabled tool groups
+ * @returns true if the tool should be included
+ */
+function shouldIncludeTool(toolDef, enabledGroups) {
+    const baseGroup = toolDef.group;
+    const readonlyGroup = `${baseGroup}_readonly`;
+    // Check if the base group (full access) is enabled
+    if (enabledGroups.includes(baseGroup)) {
+        return true;
+    }
+    // Check if the readonly group is enabled (only include read operations)
+    if (enabledGroups.includes(readonlyGroup) && !toolDef.isWriteOperation) {
+        return true;
+    }
+    return false;
+}
 /**
  * Creates a function to register all tools with the server.
  * This pattern uses individual tool files for better modularity and testability.
@@ -54,14 +125,16 @@ const ALL_TOOLS = [
  * a factory pattern that accepts the server and clientFactory as parameters.
  *
  * @param clientFactory - Factory function that creates client instances
- * @param enabledGroups - Optional array of enabled tool groups (defaults to all)
+ * @param enabledGroups - Optional string of enabled tool groups (defaults to all)
  * @returns Function that registers all tools with a server
  */
 export function createRegisterTools(clientFactory, enabledGroups) {
-    const groups = enabledGroups || parseEnabledToolGroups(process.env.ENABLED_TOOLGROUPS);
     return (server) => {
-        // Filter tools by enabled groups and create instances
-        const tools = ALL_TOOLS.filter((def) => def.groups.some((g) => groups.includes(g))).map((def) => def.factory(server, clientFactory));
+        const enabledToolGroups = parseEnabledToolGroups(enabledGroups);
+        // Filter tools based on enabled groups
+        const enabledTools = ALL_TOOLS.filter((toolDef) => shouldIncludeTool(toolDef, enabledToolGroups));
+        // Create tool instances
+        const tools = enabledTools.map((toolDef) => toolDef.factory(server, clientFactory));
         // List available tools
         server.setRequestHandler(ListToolsRequestSchema, async () => {
             return {

package/shared/types.d.ts

@@ -186,4 +186,166 @@ export interface UpdateSubagentTranscriptRequest {
     total_tokens?: number;
     tool_use_count?: number;
 }
+export type EnqueuedMessageStatus = 'pending' | 'processing' | 'sent';
+export interface EnqueuedMessage {
+    id: number;
+    session_id: number;
+    content: string;
+    stop_condition: string | null;
+    position: number;
+    status: EnqueuedMessageStatus;
+    created_at: string;
+    updated_at: string;
+}
+export interface EnqueuedMessagesResponse {
+    enqueued_messages: EnqueuedMessage[];
+    pagination: Pagination;
+}
+export interface EnqueuedMessageResponse {
+    enqueued_message: EnqueuedMessage;
+}
+export interface EnqueuedMessageInterruptResponse {
+    session: Session;
+    message: string;
+}
+export type TriggerType = 'slack' | 'schedule';
+export type TriggerStatus = 'enabled' | 'disabled';
+export interface Trigger {
+    id: number;
+    name: string;
+    trigger_type: TriggerType;
+    status: TriggerStatus;
+    agent_root_name: string;
+    prompt_template: string;
+    stop_condition: string | null;
+    reuse_session: boolean;
+    mcp_servers: string[];
+    configuration: Record<string, unknown>;
+    schedule_description: string | null;
+    last_session_id: number | null;
+    last_triggered_at: string | null;
+    last_polled_at: string | null;
+    sessions_created_count: number;
+    created_at: string;
+    updated_at: string;
+}
+export interface TriggersResponse {
+    triggers: Trigger[];
+    pagination: Pagination;
+}
+export interface TriggerResponse {
+    trigger: Trigger;
+    recent_sessions?: Session[];
+}
+export interface TriggerChannelsResponse {
+    channels: Array<{
+        id: string;
+        name: string;
+        is_private: boolean;
+        num_members: number;
+    }>;
+}
+export interface CreateTriggerRequest {
+    name: string;
+    trigger_type: TriggerType;
+    agent_root_name: string;
+    prompt_template: string;
+    status?: TriggerStatus;
+    stop_condition?: string;
+    reuse_session?: boolean;
+    mcp_servers?: string[];
+    configuration?: Record<string, unknown>;
+}
+export interface UpdateTriggerRequest {
+    name?: string;
+    trigger_type?: TriggerType;
+    agent_root_name?: string;
+    prompt_template?: string;
+    status?: TriggerStatus;
+    stop_condition?: string;
+    reuse_session?: boolean;
+    mcp_servers?: string[];
+    configuration?: Record<string, unknown>;
+}
+export interface Notification {
+    id: number;
+    session_id: number;
+    notification_type: string;
+    read: boolean;
+    stale: boolean;
+    created_at: string;
+    updated_at: string;
+    session?: {
+        id: number;
+        slug: string | null;
+        title: string;
+        status: string;
+    };
+}
+export interface NotificationsResponse {
+    notifications: Notification[];
+    pagination: Pagination;
+}
+export interface NotificationResponse {
+    notification: Notification;
+}
+export interface NotificationBadgeResponse {
+    pending_count: number;
+}
+export interface NotificationMarkAllReadResponse {
+    marked_count: number;
+    pending_count: number;
+}
+export interface NotificationDismissAllReadResponse {
+    dismissed_count: number;
+    pending_count: number;
+}
+export interface HealthReport {
+    health_report: Record<string, unknown>;
+    timestamp: string;
+    rails_env: string;
+    ruby_version: string;
+}
+export interface HealthActionResponse {
+    [key: string]: unknown;
+}
+export interface CliStatusResponse {
+    cli_status: Record<string, unknown>;
+    unauthenticated_count: number;
+}
+export interface CliActionResponse {
+    queued: boolean;
+    message: string;
+    [key: string]: unknown;
+}
+export interface ForkSessionResponse {
+    session: Session;
+    message: string;
+}
+export interface RefreshSessionResponse {
+    session: Session;
+    message: string;
+}
+export interface RefreshAllSessionsResponse {
+    message: string;
+    refreshed: number;
+    restarted: number;
+    continued: number;
+    errors: number;
+}
+export interface BulkArchiveResponse {
+    archived_count: number;
+    errors: Array<{
+        id: number;
+        error: string;
+    }>;
+}
+export interface TranscriptResponse {
+    transcript_text: string;
+}
+export interface TranscriptArchiveStatusResponse {
+    generated_at: string;
+    session_count: number;
+    file_size_bytes: number;
+}
 //# sourceMappingURL=types.d.ts.map