feat: add Webvizio integration

demo/testing/src/scripts/test-script.ts

@@ -19,10 +19,14 @@ async function setInstagramCredentials() {
 }
 
 const main = async () => {
-	const res = await corsair.slack.api.messages.post({
-		channel: 'general',
-		text: 'hello',
-	});
+        const res = await corsair.slack.api.messages.post({
+                channel: 'general',
+                text: 'hello',
+        });
+
+        const projects = await corsair.webvizio.api.projects.list({});
+
+        console.log('Webvizio projects:', projects);
 };
 
 main().catch((err) => {

demo/testing/src/server/corsair.ts

@@ -13,6 +13,7 @@ import { sharepoint } from '@corsair-dev/sharepoint';
 import { slack } from '@corsair-dev/slack';
 import { twilio } from '@corsair-dev/twilio';
 import { vapi } from '@corsair-dev/vapi';
+import { webvizio } from '@corsair-dev/webvizio';
 import { createCorsair } from 'corsair';
 
 import { sqlite } from '../db';
@@ -63,6 +64,9 @@ export const corsair = createCorsair({
 			key: process.env.VAPI_API_KEY,
 			webhookSecret: process.env.VAPI_WEBHOOK_SECRET,
 		}),
+webvizio({
+key: process.env.WEBVIZIO_API_KEY,
+}),
 		instagram(),
 	],
 });

packages/corsair/core/constants.ts

@@ -187,6 +187,7 @@ export const BaseProviders = [
 	'vapi',
 	'vercel',
 	'webflow',
+	'webvizio',
 	'whatsapp',
 	'witai',
 	'wiza',
@@ -375,6 +376,7 @@ export const ProviderDisplayNames = {
 	vapi: 'Vapi',
 	vercel: 'Vercel',
 	webflow: 'Webflow',
+	webvizio: 'Webvizio',
 	whatsapp: 'WhatsApp',
 	witai: 'WitAi',
 	wiza: 'Wiza',
@@ -570,6 +572,7 @@ export type AllProviders =
 	| 'vapi'
 	| 'vercel'
 	| 'webflow'
+	| 'webvizio'
 	| 'whatsapp'
 	| 'witai'
 	| 'wiza'

packages/webvizio/client.ts

@@ -0,0 +1,81 @@
+import type { ApiRequestOptions, OpenAPIConfig } from 'corsair/http';
+import { ApiError, request } from 'corsair/http';
+
+export class WebvizioAPIError extends Error {
+        constructor(
+                message: string,
+                public readonly code?: string | number,
+        ) {
+                super(message);
+                this.name = 'WebvizioAPIError';
+        }
+}
+
+const WEBVIZIO_MCP_API_BASE = 'https://app.webvizio.com/api/mcp/v1';
+const WEBVIZIO_WEBHOOK_API_BASE = 'https://app.webvizio.com/api/v1';
+
+export async function makeWebvizioRequest<T>(
+        endpoint: string,
+        apiKey: string,
+        options: {
+                method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+                body?: Record<string, unknown>;
+                query?: Record<string, string | number | boolean | undefined>;
+                baseUrl?: string;
+        } = {},
+): Promise<T> {
+        const {
+                method = 'GET',
+                body,
+                query,
+                baseUrl = WEBVIZIO_MCP_API_BASE,
+        } = options;
+
+        const config: OpenAPIConfig = {
+                BASE: baseUrl,
+                VERSION: '1.0.0',
+                WITH_CREDENTIALS: false,
+                CREDENTIALS: 'omit',
+                TOKEN: apiKey,
+                HEADERS: {
+                        'Content-Type': 'application/json',
+                        Accept: 'application/json',
+                        Authorization: `Bearer ${apiKey}`,
+                },
+        };
+
+        const requestOptions: ApiRequestOptions = {
+                method,
+                url: endpoint,
+                body:
+                        method === 'POST' || method === 'PUT' || method === 'PATCH'
+                                ? body
+                                : undefined,
+                mediaType: 'application/json',
+                query,
+        };
+
+        try {
+                return await request<T>(config, requestOptions);
+        } catch (error) {
+                if (error instanceof ApiError) {
+                        const detail =
+                                typeof error.body === 'object'
+                                        ? JSON.stringify(error.body)
+                                        : String(error.body ?? '');
+
+                        throw new WebvizioAPIError(
+                                `${error.message} (status=${error.status}, body=${detail})`,
+                                error.status,
+                        );
+                }
+
+                if (error instanceof WebvizioAPIError) {
+                        throw error;
+                }
+
+                throw new WebvizioAPIError(
+                        error instanceof Error ? error.message : 'Unknown error',
+                );
+        }
+}

packages/webvizio/endpoints/index.ts

@@ -0,0 +1,12 @@
+import { list as projectsList } from './projects';
+import { list as webhooksList } from './webhooks';
+
+export const Projects = {
+        list: projectsList,
+};
+
+export const Webhooks = {
+        list: webhooksList,
+};
+
+export * from './types';

packages/webvizio/endpoints/projects.ts

@@ -0,0 +1,24 @@
+import { logEventFromContext } from 'corsair/core';
+import { makeWebvizioRequest } from '../client';
+import type { WebvizioEndpoints } from '../index';
+
+export const list: WebvizioEndpoints['projectsList'] = async (ctx, input) => {
+        const result = await makeWebvizioRequest<unknown[]>(
+                '/projects',
+                ctx.key,
+        );
+
+        await logEventFromContext(
+                ctx,
+                'webvizio.projects.list',
+                { ...input },
+                'completed',
+        );
+
+        return result as WebvizioEndpoints['projectsList'] extends (
+                ctx: infer _,
+                input: infer _,
+        ) => Promise<infer R>
+                ? R
+                : never;
+};

packages/webvizio/endpoints/types.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+
+const WebvizioProjectSchema = z
+        .object({
+                id: z.string(),
+                name: z.string().optional(),
+                description: z.string().optional(),
+        })
+        .passthrough();
+
+export type WebvizioProject = z.infer<typeof WebvizioProjectSchema>;
+
+const WebvizioWebhookSubscriptionSchema = z
+        .object({
+                id: z.string().optional(),
+                url: z.string().optional(),
+                event: z.string().optional(),
+        })
+        .passthrough();
+
+export type WebvizioWebhookSubscription = z.infer<
+        typeof WebvizioWebhookSubscriptionSchema
+>;
+
+export type WebvizioEndpointInputs = {
+        projectsList: Record<string, never>;
+        webhooksList: Record<string, never>;
+};
+
+export type WebvizioEndpointOutputs = {
+        projectsList: WebvizioProject[];
+        webhooksList: WebvizioWebhookSubscription[];
+};
+
+export const WebvizioEndpointInputSchemas = {
+        projectsList: z.object({}),
+        webhooksList: z.object({}),
+} as const;
+
+export const WebvizioEndpointOutputSchemas = {
+        projectsList: z.array(WebvizioProjectSchema),
+        webhooksList: z.array(WebvizioWebhookSubscriptionSchema),
+} as const;

packages/webvizio/endpoints/webhooks.ts

@@ -0,0 +1,28 @@
+import { logEventFromContext } from 'corsair/core';
+import { makeWebvizioRequest } from '../client';
+import type { WebvizioEndpoints } from '../index';
+
+export const list: WebvizioEndpoints['webhooksList'] = async (ctx, input) => {
+        const result = await makeWebvizioRequest<unknown[]>(
+                '/webhook',
+                ctx.key,
+                {
+                        baseUrl: 'https://app.webvizio.com/api/v1',
+                },
+        );
+
+        await logEventFromContext(
+                ctx,
+                'webvizio.webhooks.list',
+                { ...input },
+                'completed',
+        );
+
+        return result as WebvizioEndpoints['webhooksList'] extends (
+                ctx: infer _,
+                input: infer _,
+        ) => Promise<infer R>
+                ? R
+
+: never;
+};

packages/webvizio/error-handlers.ts

@@ -0,0 +1,31 @@
+import { ApiError } from 'corsair/http';
+import type { CorsairErrorHandler } from 'corsair/core';
+
+export const errorHandlers = {
+	RATE_LIMIT_ERROR: {
+		match: (error: Error) => {
+			if (error instanceof ApiError && error.status === 429) return true;
+			const msg = error.message.toLowerCase();
+			return msg.includes('rate_limited') || msg.includes('429');
+		},
+		handler: async (error: Error) => {
+			let retryAfterMs: number | undefined;
+			if (error instanceof ApiError && error.retryAfter !== undefined) {
+				retryAfterMs = error.retryAfter;
+			}
+			return { maxRetries: 5, headersRetryAfterMs: retryAfterMs };
+		},
+	},
+	AUTH_ERROR: {
+		match: (error: Error) => {
+			if (error instanceof ApiError && error.status === 401) return true;
+			const msg = error.message.toLowerCase();
+			return msg.includes('unauthorized') || msg.includes('invalid_auth');
+		},
+		handler: async () => ({ maxRetries: 0 }),
+	},
+	DEFAULT: {
+		match: () => true,
+		handler: async () => ({ maxRetries: 0 }),
+	},
+} satisfies CorsairErrorHandler;