@alertee/cli 0.3.1 → 0.7.0

package/dist/mcp.js

@@ -4,7 +4,7 @@
  * Start via: alertee mcp  (or npx @alertee/cli mcp)
  */
 import { createClient } from './api.js';
-import { loadConfig, resolveOrgId, resolveToken, usingEnvToken } from './config.js';
+import { loadConfig, resolveOrgId, resolveToken, saveConfig, usingEnvToken } from './config.js';
 import { MINUTES_TO_INTERVAL } from './intervals.js';
 /** Org is required unless credentials come from the env (default-org fallback). */
 function needsOrg(config) {
@@ -64,6 +64,10 @@ const TOOLS = [
                     type: 'string',
                     description: 'Grid only (optional): query returning `name` and `label` columns to map dimension keys to display names.',
                 },
+                alert_group_id: {
+                    type: 'string',
+                    description: 'Optional: route alerts to this alert group (defaults to the org default group).',
+                },
                 interval_minutes: {
                     type: 'number',
                     enum: [1, 5, 15, 30, 60],
@@ -120,6 +124,17 @@ const TOOLS = [
                     description: 'Grid only: cell severity for the replacement condition',
                 },
                 custom_message: { type: 'string', description: 'Grid only: custom alert message' },
+                managed_by: {
+                    type: 'string',
+                    enum: ['user', 'alertee'],
+                    description: "Who maintains the check: 'user' (you own the SQL) or 'alertee' (Alertee re-authors/re-reviews it on a cadence)",
+                },
+                calendar: {
+                    type: 'string',
+                    enum: ['NYSE', 'LSE', 'TSX', 'XETRA', 'EURONEXT'],
+                    description: 'Follow a market trading calendar so the check is quiet outside trading hours and on exchange holidays/weekends',
+                },
+                clear_calendar: { type: 'boolean', description: 'Stop following a market calendar' },
             },
             required: ['id'],
         },
@@ -155,6 +170,170 @@ const TOOLS = [
         description: 'List organizations the authenticated user belongs to.',
         inputSchema: { type: 'object', properties: {}, required: [] },
     },
+    {
+        name: 'create_organization',
+        description: 'Create a new Alertee organization and switch the linked organization to it (so subsequent create_connection / create_check calls target it). The authenticated user becomes the owner.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Human-readable organization name' },
+                slug: {
+                    type: 'string',
+                    description: 'Optional URL-safe slug; auto-generated from the name when omitted.',
+                },
+            },
+            required: ['name'],
+        },
+    },
+    {
+        name: 'create_connection',
+        description: 'Create a database connection in the linked organization. The connection_string is encrypted server-side and tested before saving, so a bad URI or unreachable host returns an error. Use the returned connection id with create_check.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Human-readable connection name' },
+                type: {
+                    type: 'string',
+                    enum: ['postgres', 'clickhouse'],
+                    description: 'Database type',
+                },
+                connection_string: {
+                    type: 'string',
+                    description: 'Connection URI, e.g. postgres://user:pass@host:5432/db',
+                },
+            },
+            required: ['name', 'type', 'connection_string'],
+        },
+    },
+    {
+        name: 'test_connection',
+        description: 'Test an existing database connection by ID; returns success plus detected permissions.',
+        inputSchema: {
+            type: 'object',
+            properties: { id: { type: 'string', description: 'Connection ID' } },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'list_alert_groups',
+        description: 'List alert groups in the linked organization. A group routes a check\'s alerts to its recipients.',
+        inputSchema: { type: 'object', properties: {}, required: [] },
+    },
+    {
+        name: 'create_alert_group',
+        description: 'Create an alert group (a container for recipients). Add recipients with add_alert_recipient. Route a check to it via create_check\'s alert_group_id.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Alert group name' },
+                description: { type: 'string', description: 'Optional description' },
+                is_default: {
+                    type: 'boolean',
+                    description: 'Make this the org default group (used by checks with no group set).',
+                },
+            },
+            required: ['name'],
+        },
+    },
+    {
+        name: 'delete_alert_group',
+        description: 'Delete an alert group by ID. Checks using it fall back to the default group.',
+        inputSchema: {
+            type: 'object',
+            properties: { id: { type: 'string', description: 'Alert group ID' } },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'list_alert_recipients',
+        description: 'List the recipients (channels) in an alert group.',
+        inputSchema: {
+            type: 'object',
+            properties: { alert_group_id: { type: 'string', description: 'Alert group ID' } },
+            required: ['alert_group_id'],
+        },
+    },
+    {
+        name: 'add_alert_recipient',
+        description: 'Add a recipient to an alert group. For a webhook, pass type "webhook" + url. For an email list, pass type "email_group" + email_group_id (create one with create_email_group). Slack is configured in the web UI.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                alert_group_id: { type: 'string', description: 'Alert group ID' },
+                type: { type: 'string', enum: ['webhook', 'email_group'], description: 'Recipient type' },
+                url: { type: 'string', description: 'Webhook URL (required when type is webhook)' },
+                email_group_id: {
+                    type: 'string',
+                    description: 'Email group ID (required when type is email_group)',
+                },
+            },
+            required: ['alert_group_id', 'type'],
+        },
+    },
+    {
+        name: 'remove_alert_recipient',
+        description: 'Remove a recipient from an alert group by its channel ID (from list_alert_recipients).',
+        inputSchema: {
+            type: 'object',
+            properties: { channel_id: { type: 'string', description: 'Channel ID' } },
+            required: ['channel_id'],
+        },
+    },
+    {
+        name: 'list_email_groups',
+        description: 'List email groups (recipient lists) in the linked organization.',
+        inputSchema: { type: 'object', properties: {}, required: [] },
+    },
+    {
+        name: 'create_email_group',
+        description: 'Create an email group (a reusable list of email recipients), optionally with initial member emails. Attach it to an alert group with add_alert_recipient (type email_group).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Email group name' },
+                description: { type: 'string', description: 'Optional description' },
+                members: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Initial member email addresses',
+                },
+            },
+            required: ['name'],
+        },
+    },
+    {
+        name: 'delete_email_group',
+        description: 'Delete an email group by ID. Alert groups using it lose those recipients.',
+        inputSchema: {
+            type: 'object',
+            properties: { id: { type: 'string', description: 'Email group ID' } },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'add_email_group_members',
+        description: 'Add one or more email addresses to an email group.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'Email group ID' },
+                emails: { type: 'array', items: { type: 'string' }, description: 'Email addresses to add' },
+            },
+            required: ['id', 'emails'],
+        },
+    },
+    {
+        name: 'remove_email_group_member',
+        description: 'Remove an email address from an email group.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'Email group ID' },
+                email: { type: 'string', description: 'Email address to remove' },
+            },
+            required: ['id', 'email'],
+        },
+    },
     {
         name: 'snooze_check',
         description: "Temporarily silence a check's alerts. Defaults to the rest of today; pass `until` for a specific end time. Auto-expires — no need to un-snooze.",
@@ -204,6 +383,107 @@ const TOOLS = [
             required: ['id'],
         },
     },
+    {
+        name: 'list_inbox',
+        description: 'List inbox items (incidents) in the linked organization. Filter by status and/or severity.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                status: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Filter by status, e.g. ["open"], ["acknowledged"], ["resolved"]',
+                },
+                severity: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Filter by severity, e.g. ["critical","warning"]',
+                },
+                limit: { type: 'number', description: 'Max items to fetch (default 50)' },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'get_inbox_item',
+        description: 'Get a single inbox item (incident) and its timeline by ID.',
+        inputSchema: {
+            type: 'object',
+            properties: { id: { type: 'string', description: 'Inbox item (incident) ID' } },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'acknowledge_inbox_item',
+        description: 'Acknowledge an inbox item (incident) by ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'Inbox item ID' },
+                note: { type: 'string', description: 'Optional note' },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'resolve_inbox_item',
+        description: 'Resolve an inbox item (incident) by ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'Inbox item ID' },
+                note: { type: 'string', description: 'Optional note' },
+                outcome: { type: 'string', description: 'Optional outcome summary' },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'get_inbox_digest',
+        description: 'Get the inbox digest — a briefing plus active/critical/resolved incident counts.',
+        inputSchema: { type: 'object', properties: {}, required: [] },
+    },
+    {
+        name: 'list_webhook_receivers',
+        description: 'List inbound webhook receivers in the linked organization.',
+        inputSchema: { type: 'object', properties: {}, required: [] },
+    },
+    {
+        name: 'create_webhook_receiver',
+        description: 'Create an inbound webhook receiver. Returns the receiver and the webhookUrl external tools POST to in order to open inbox incidents.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Receiver name' },
+                severity: {
+                    type: 'string',
+                    enum: ['info', 'warning', 'error', 'critical'],
+                    description: 'Incident severity (default warning)',
+                },
+                title_template: { type: 'string', description: 'Template for the incident title' },
+                description_template: { type: 'string', description: 'Template for the incident description' },
+                alert_group_ids: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Alert group IDs to notify when this receiver fires',
+                },
+                auto_resolve_on_recovery: {
+                    type: 'boolean',
+                    description: 'Auto-resolve the incident when a recovery signal arrives',
+                },
+            },
+            required: ['name'],
+        },
+    },
+    {
+        name: 'delete_webhook_receiver',
+        description: 'Delete an inbound webhook receiver by ID.',
+        inputSchema: {
+            type: 'object',
+            properties: { id: { type: 'string', description: 'Webhook receiver ID' } },
+            required: ['id'],
+        },
+    },
 ];
 /**
  * Build a ConditionBody from tool args. Returns null when no condition fields
@@ -270,6 +550,178 @@ async function callTool(name, args) {
             const data = await client.listOrganizations();
             return JSON.stringify(data.organizations, null, 2);
         }
+        case 'create_organization': {
+            const resp = await client.createOrganization({
+                name: args.name,
+                slug: args.slug,
+            });
+            const org = resp.organization;
+            // Auto-link so subsequent create_connection / create_check target the new
+            // org (mirrors `alertee org create`). Only when using file config — env
+            // credentials (ALERTEE_ORG/ALERTEE_TOKEN) are managed outside the CLI.
+            if (!usingEnvToken()) {
+                const existing = loadConfig();
+                saveConfig({
+                    ...(existing ?? { token: '', apiUrl: '' }),
+                    organizationId: org.id,
+                    organizationName: org.name,
+                });
+            }
+            return JSON.stringify({ ...org, linked: !usingEnvToken() }, null, 2);
+        }
+        case 'create_connection': {
+            {
+                const m = needsOrg(config);
+                if (m)
+                    return m;
+            }
+            const resp = await client.upsertConnection({
+                name: args.name,
+                type: args.type.toLowerCase(),
+                connection_string: args.connection_string,
+            });
+            return JSON.stringify(resp.connection, null, 2);
+        }
+        case 'test_connection': {
+            {
+                const m = needsOrg(config);
+                if (m)
+                    return m;
+            }
+            const res = await client.testConnection(args.id);
+            return JSON.stringify(res, null, 2);
+        }
+        case 'list_alert_groups': {
+            {
+                const m = needsOrg(config);
+                if (m)
+                    return m;
+            }
+            const data = await client.listAlertGroups();
+            return JSON.stringify(data.alert_groups, null, 2);
+        }
+        case 'create_alert_group': {
+            {
+                const m = needsOrg(config);
+                if (m)
+                    return m;
+            }
+            const resp = await client.createAlertGroup({
+                name: args.name,
+                description: args.description ?? '',
+                is_default: args.is_default ?? false,
+            });
+            return JSON.stringify(resp.alert_group, null, 2);
+        }
+        case 'delete_alert_group': {
+            {
+                const m = needsOrg(config);
+                if (m)
+                    return m;
+            }
+            await client.deleteAlertGroup(args.id);
+            return `Deleted alert group ${args.id}`;
+        }
+        case 'list_alert_recipients': {
+            {
+                const m = needsOrg(config);
+                if (m)
+                    return m;
+            }
+            const data = await client.listAlertChannels(args.alert_group_id);
+            return JSON.stringify(data.channels, null, 2);
+        }
+        case 'add_alert_recipient': {
+            {
+                const m = needsOrg(config);
+                if (m)
+                    return m;
+            }
+            const type = args.type;
+            if (type === 'webhook') {
+                if (!args.url)
+                    return 'A webhook recipient requires a url.';
+                const channel = await client.createAlertChannel({
+                    alert_group_id: args.alert_group_id,
+                    channel_type: 'webhook',
+                    config: { url: args.url },
+                    email_group_id: null,
+                });
+                return JSON.stringify(channel, null, 2);
+            }
+            if (type === 'email_group') {
+                if (!args.email_group_id)
+                    return 'An email_group recipient requires an email_group_id.';
+                const channel = await client.createAlertChannel({
+                    alert_group_id: args.alert_group_id,
+                    channel_type: 'email_group',
+                    config: {},
+                    email_group_id: args.email_group_id,
+                });
+                return JSON.stringify(channel, null, 2);
+            }
+            return `Unsupported recipient type "${type}". Use "webhook" or "email_group".`;
+        }
+        case 'remove_alert_recipient': {
+            {
+                const m = needsOrg(config);
+                if (m)
+                    return m;
+            }
+            await client.deleteAlertChannel(args.channel_id);
+            return `Removed recipient ${args.channel_id}`;
+        }
+        case 'list_email_groups': {
+            {
+                const m = needsOrg(config);
+                if (m)
+                    return m;
+            }
+            const data = await client.listEmailGroups();
+            return JSON.stringify(data.groups, null, 2);
+        }
+        case 'create_email_group': {
+            {
+                const m = needsOrg(config);
+                if (m)
+                    return m;
+            }
+            const group = await client.createEmailGroup({
+                name: args.name,
+                description: args.description,
+                auto_add_members: false,
+                is_default: false,
+                members: args.members,
+            });
+            return JSON.stringify(group, null, 2);
+        }
+        case 'delete_email_group': {
+            {
+                const m = needsOrg(config);
+                if (m)
+                    return m;
+            }
+            await client.deleteEmailGroup(args.id);
+            return `Deleted email group ${args.id}`;
+        }
+        case 'add_email_group_members': {
+            {
+                const m = needsOrg(config);
+                if (m)
+                    return m;
+            }
+            await client.addEmailGroupMembers(args.id, args.emails);
+            return `Added ${args.emails.length} address(es).`;
+        }
+        case 'remove_email_group_member': {
+            {
+                const m = needsOrg(config);
+                if (m)
+                    return m;
+            }
+            await client.removeEmailGroupMember(args.id, args.email);
+            return `Removed ${args.email}.`;
+        }
         case 'get_check': {
             {
                 const m = needsOrg(config);
@@ -321,6 +773,7 @@ async function callTool(name, args) {
                 query: args.query,
                 condition,
                 interval,
+                alert_group_id: args.alert_group_id,
                 label_query: args.label_query,
             });
             return JSON.stringify(resp.check, null, 2);
@@ -356,11 +809,29 @@ async function callTool(name, args) {
             if (condition) {
                 body.condition = condition;
             }
-            if (Object.keys(body).length === 0) {
+            const touchesManaged = args.managed_by !== undefined;
+            const touchesCalendar = args.calendar !== undefined || args.clear_calendar === true;
+            if (Object.keys(body).length === 0 && !touchesManaged && !touchesCalendar) {
                 return 'Nothing to update. Provide at least one field to change.';
             }
-            await client.patchCheck(args.id, body);
-            return `Updated check ${args.id}`;
+            const id = args.id;
+            const done = [];
+            if (Object.keys(body).length > 0) {
+                await client.patchCheck(id, body);
+                done.push('fields');
+            }
+            if (touchesManaged) {
+                const res = await client.setCheckManagement(id, { managed_by: args.managed_by });
+                done.push(`managed_by=${res.managed_by}`);
+            }
+            if (touchesCalendar) {
+                await client.setCheckMarketCalendar(id, {
+                    calendar: args.calendar,
+                    clear: args.clear_calendar,
+                });
+                done.push(args.clear_calendar ? 'calendar cleared' : `calendar=${args.calendar}`);
+            }
+            return `Updated check ${id} (${done.join(', ')})`;
         }
         case 'delete_check': {
             {
@@ -403,6 +874,97 @@ async function callTool(name, args) {
             });
             return JSON.stringify(res, null, 2);
         }
+        case 'list_inbox': {
+            {
+                const m = needsOrg(config);
+                if (m)
+                    return m;
+            }
+            const orgId = resolveOrgId(config);
+            if (!orgId)
+                return 'No organization linked. Run `alertee link` (or set ALERTEE_ORG).';
+            const data = await client.listIssues({
+                organizationId: orgId,
+                status: args.status,
+                severity: args.severity,
+                limit: args.limit || 50,
+                offset: 0,
+            });
+            return JSON.stringify(data.issues, null, 2);
+        }
+        case 'get_inbox_item': {
+            {
+                const m = needsOrg(config);
+                if (m)
+                    return m;
+            }
+            const data = await client.getIssue(args.id);
+            return JSON.stringify(data, null, 2);
+        }
+        case 'acknowledge_inbox_item': {
+            {
+                const m = needsOrg(config);
+                if (m)
+                    return m;
+            }
+            await client.acknowledgeIssue(args.id, { note: args.note });
+            return `Acknowledged ${args.id}`;
+        }
+        case 'resolve_inbox_item': {
+            {
+                const m = needsOrg(config);
+                if (m)
+                    return m;
+            }
+            await client.resolveIssue(args.id, {
+                note: args.note,
+                outcome: args.outcome,
+            });
+            return `Resolved ${args.id}`;
+        }
+        case 'get_inbox_digest': {
+            {
+                const m = needsOrg(config);
+                if (m)
+                    return m;
+            }
+            const data = await client.getInboxDigest();
+            return JSON.stringify(data.summary, null, 2);
+        }
+        case 'list_webhook_receivers': {
+            {
+                const m = needsOrg(config);
+                if (m)
+                    return m;
+            }
+            const data = await client.listWebhookReceivers();
+            return JSON.stringify(data.receivers, null, 2);
+        }
+        case 'create_webhook_receiver': {
+            {
+                const m = needsOrg(config);
+                if (m)
+                    return m;
+            }
+            const result = await client.createWebhookReceiver({
+                name: args.name,
+                severity: (args.severity || 'warning').toLowerCase(),
+                titleTemplate: args.title_template ?? '',
+                descriptionTemplate: args.description_template ?? '',
+                autoResolveOnRecovery: args.auto_resolve_on_recovery ?? false,
+                alertGroupIds: args.alert_group_ids,
+            });
+            return JSON.stringify(result, null, 2);
+        }
+        case 'delete_webhook_receiver': {
+            {
+                const m = needsOrg(config);
+                if (m)
+                    return m;
+            }
+            await client.deleteWebhookReceiver(args.id);
+            return `Deleted webhook receiver ${args.id}`;
+        }
         default:
             return `Unknown tool: ${name}`;
     }
@@ -422,7 +984,7 @@ async function handleRequest(req) {
         respond(req.id, {
             protocolVersion: '2024-11-05',
             capabilities: { tools: {} },
-            serverInfo: { name: 'alertee', version: '0.3.1' },
+            serverInfo: { name: 'alertee', version: '0.7.0' },
         });
         return;
     }