@rnsk/toolkits 0.0.10 → 0.0.11

package/dist/toolkits/convex/tools/deployments.js

@@ -0,0 +1,126 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { convexMgmt, toConvexError, requireToken } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+export const convexCreateDeployment = tool({
+    description: 'Create a dev, prod, or custom deployment in a project, with optional class, reference, and region. Returns the deployment name and URL.',
+    inputSchema: z.object({
+        convexToken: tokenField,
+        projectId: z.number().describe('Numeric project ID'),
+        type: z.enum(['dev', 'prod', 'custom']).describe('Deployment type'),
+        deploymentClass: z.string().optional().describe('Deployment class (defaults to the team default)'),
+        reference: z.string().optional().describe('Unique reference within the project (auto-generated when omitted)'),
+        region: z.string().optional().describe('Hosting region (defaults to the team default)'),
+    }),
+    execute: async ({ convexToken, projectId, type, deploymentClass, reference, region }) => {
+        try {
+            const missing = requireToken(convexToken);
+            if (missing)
+                return missing;
+            return await convexMgmt(convexToken, 'POST', `/projects/${projectId}/create_deployment`, {
+                body: {
+                    type,
+                    class: deploymentClass,
+                    reference,
+                    region,
+                },
+            });
+        }
+        catch (error) {
+            return toConvexError(error, 'Failed to create deployment');
+        }
+    },
+});
+export const convexListDeployments = tool({
+    description: 'List deployments for a project (production, preview, and optionally local), with filters for default status, type, and local inclusion.',
+    inputSchema: z.object({
+        convexToken: tokenField,
+        projectId: z.number().describe('Numeric project ID'),
+        isDefault: z.boolean().optional().describe('True for default deployments only, false for non-default only'),
+        includeLocal: z.boolean().optional().describe('Include local deployments (only your own)'),
+        deploymentType: z.string().optional().describe('Filter by deployment type'),
+    }),
+    execute: async ({ convexToken, projectId, isDefault, includeLocal, deploymentType }) => {
+        try {
+            const missing = requireToken(convexToken);
+            if (missing)
+                return missing;
+            const data = await convexMgmt(convexToken, 'GET', `/projects/${projectId}/list_deployments`, {
+                query: {
+                    isDefault,
+                    includeLocal,
+                    deploymentType,
+                },
+            });
+            return Array.isArray(data) ? { items: data } : data;
+        }
+        catch (error) {
+            return toConvexError(error, 'Failed to list deployments');
+        }
+    },
+});
+export const convexGetDeployment = tool({
+    description: 'Get details for a deployment by name: configuration, region, creation time, and status.',
+    inputSchema: z.object({
+        convexToken: tokenField,
+        deploymentName: z.string().describe("Deployment name, e.g. 'quiet-llama-744'"),
+    }),
+    execute: async ({ convexToken, deploymentName }) => {
+        try {
+            const missing = requireToken(convexToken);
+            if (missing)
+                return missing;
+            return await convexMgmt(convexToken, 'GET', `/deployments/${deploymentName}`);
+        }
+        catch (error) {
+            return toConvexError(error, 'Failed to get deployment');
+        }
+    },
+});
+export const convexUpdateDeployment = tool({
+    description: 'Update deployment settings (reference, dashboard edit confirmation). Only provided fields are modified.',
+    inputSchema: z.object({
+        convexToken: tokenField,
+        deploymentName: z.string().describe('Deployment name to update'),
+        reference: z.string().optional().describe('Unique reference (3-100 chars, lowercase, numbers, - and /)'),
+        dashboardEditConfirmation: z.boolean().optional().describe('Require dashboard confirmation before edits'),
+    }),
+    execute: async ({ convexToken, deploymentName, reference, dashboardEditConfirmation }) => {
+        try {
+            const missing = requireToken(convexToken);
+            if (missing)
+                return missing;
+            const data = await convexMgmt(convexToken, 'PATCH', `/deployments/${deploymentName}`, {
+                body: {
+                    reference,
+                    dashboardEditConfirmation,
+                },
+            });
+            return data && Object.keys(data).length ? data : { success: true, deployment_name: deploymentName };
+        }
+        catch (error) {
+            return toConvexError(error, 'Failed to update deployment');
+        }
+    },
+});
+export const convexDeleteDeployment = tool({
+    description: 'Permanently delete a deployment and all its data and files. Irreversible — confirm with the user first.',
+    inputSchema: z.object({
+        convexToken: tokenField,
+        deploymentName: z.string().describe('Deployment name to delete'),
+    }),
+    execute: async ({ convexToken, deploymentName }) => {
+        try {
+            const missing = requireToken(convexToken);
+            if (missing)
+                return missing;
+            await convexMgmt(convexToken, 'POST', `/deployments/${deploymentName}/delete`, { body: {} });
+            return { success: true, deployment_name: deploymentName };
+        }
+        catch (error) {
+            return toConvexError(error, 'Failed to delete deployment');
+        }
+    },
+});
+//# sourceMappingURL=deployments.js.map

package/dist/toolkits/convex/tools/domains.d.ts

@@ -0,0 +1,7 @@
+export declare const convexDeleteCustomDomain: import("ai").Tool<{
+    domain: string;
+    deploymentName: string;
+    requestDestination: "convexCloud" | "convexSite";
+    convexToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=domains.d.ts.map

package/dist/toolkits/convex/tools/domains.js

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { convexMgmt, toConvexError, requireToken } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+export const convexDeleteCustomDomain = tool({
+    description: 'Remove a custom domain from a deployment. Specify whether it serves the Convex Cloud backend or the Convex Site frontend. Confirm with the user first.',
+    inputSchema: z.object({
+        convexToken: tokenField,
+        deploymentName: z.string().describe('Deployment the domain is configured on'),
+        domain: z.string().describe("Custom domain to delete, e.g. 'app.mydomain.com'"),
+        requestDestination: z.enum(['convexCloud', 'convexSite']).describe('Domain destination to remove'),
+    }),
+    execute: async ({ convexToken, deploymentName, domain, requestDestination }) => {
+        try {
+            const missing = requireToken(convexToken);
+            if (missing)
+                return missing;
+            const data = await convexMgmt(convexToken, 'POST', `/deployments/${deploymentName}/delete_custom_domain`, {
+                body: { requestDestination, domain },
+            });
+            return data && Object.keys(data).length ? data : { success: true, domain };
+        }
+        catch (error) {
+            return toConvexError(error, 'Failed to delete custom domain');
+        }
+    },
+});
+//# sourceMappingURL=domains.js.map

package/dist/toolkits/convex/tools/functions.d.ts

@@ -0,0 +1,14 @@
+export declare const convexExecuteQueryBatch: import("ai").Tool<{
+    deploymentUrl: string;
+    queries: {
+        path: string;
+        args?: Record<string, any> | undefined;
+        format?: string | undefined;
+    }[];
+    convexToken?: string | undefined;
+}, any>;
+export declare const convexGetQueryTimestamp: import("ai").Tool<{
+    deploymentName: string;
+    convexToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=functions.d.ts.map

package/dist/toolkits/convex/tools/functions.js

@@ -0,0 +1,49 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { convexDeployment, toConvexError, requireToken } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+const queryItem = z.object({
+    path: z.string().describe("Query function path, e.g. 'messages:list'"),
+    args: z.record(z.any()).optional().describe('Named arguments (empty object when none)'),
+    format: z.string().optional().describe("Output format (only 'json' is supported)"),
+});
+export const convexExecuteQueryBatch = tool({
+    description: 'Run multiple query functions against a deployment in one batch call. Results come back in request order with per-query status, value, and log lines.',
+    inputSchema: z.object({
+        convexToken: tokenField,
+        deploymentUrl: z.string().describe("Full deployment URL, e.g. 'https://quiet-llama-744.convex.cloud'"),
+        queries: z.array(queryItem).min(1).describe('Queries to execute in order'),
+    }),
+    execute: async ({ convexToken, deploymentUrl, queries }) => {
+        try {
+            const missing = requireToken(convexToken);
+            if (missing)
+                return missing;
+            const data = await convexDeployment(convexToken, deploymentUrl, 'POST', '/api/query_batch', queries);
+            return Array.isArray(data) ? { results: data } : data;
+        }
+        catch (error) {
+            return toConvexError(error, 'Failed to execute query batch');
+        }
+    },
+});
+export const convexGetQueryTimestamp = tool({
+    description: 'Get the latest query timestamp (base64) for a deployment. Use for consistent reads or auditing the deployment state.',
+    inputSchema: z.object({
+        convexToken: tokenField,
+        deploymentName: z.string().describe("Deployment name, e.g. 'quiet-llama-744'"),
+    }),
+    execute: async ({ convexToken, deploymentName }) => {
+        try {
+            const missing = requireToken(convexToken);
+            if (missing)
+                return missing;
+            return await convexDeployment(convexToken, `https://${deploymentName}.convex.cloud`, 'POST', '/api/query_ts');
+        }
+        catch (error) {
+            return toConvexError(error, 'Failed to get query timestamp');
+        }
+    },
+});
+//# sourceMappingURL=functions.js.map

package/dist/toolkits/convex/tools/index.d.ts

@@ -0,0 +1,176 @@
+import { convexCreateProject, convexListProjects, convexGetProjectById, convexGetProjectBySlug, convexDeleteProject } from './projects.js';
+import { convexCreateDeployment, convexListDeployments, convexGetDeployment, convexUpdateDeployment, convexDeleteDeployment } from './deployments.js';
+import { convexCreateDeployKey, convexListDeployKeys } from './deploy-keys.js';
+import { convexDeleteCustomDomain } from './domains.js';
+import { convexGetTokenDetails, convexListDeploymentClasses, convexListDeploymentRegions } from './teams.js';
+import { convexExecuteQueryBatch, convexGetQueryTimestamp } from './functions.js';
+import { convexListLogStreams } from './logging.js';
+export { convexCreateProject, convexListProjects, convexGetProjectById, convexGetProjectBySlug, convexDeleteProject, convexCreateDeployment, convexListDeployments, convexGetDeployment, convexUpdateDeployment, convexDeleteDeployment, convexCreateDeployKey, convexListDeployKeys, convexDeleteCustomDomain, convexGetTokenDetails, convexListDeploymentClasses, convexListDeploymentRegions, convexExecuteQueryBatch, convexGetQueryTimestamp, convexListLogStreams, };
+export declare const convexTools: ({
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        teamId: string | number;
+        projectName: string;
+        deploymentType?: string | undefined;
+        convexToken?: string | undefined;
+        deploymentClass?: string | undefined;
+        deploymentRegion?: string | undefined;
+    }, any>;
+    requiredAuth: "convexToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        teamId: string | number;
+        convexToken?: string | undefined;
+    }, any>;
+    requiredAuth: "convexToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        projectId: number;
+        convexToken?: string | undefined;
+    }, any>;
+    requiredAuth: "convexToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        teamIdOrSlug: string | number;
+        projectSlug: string;
+        convexToken?: string | undefined;
+    }, any>;
+    requiredAuth: "convexToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        projectId: number;
+        convexToken?: string | undefined;
+    }, {
+        error: string;
+    } | {
+        success: boolean;
+        project_id: number;
+    }>;
+    requiredAuth: "convexToken";
+    scope: "delete";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        type: "custom" | "dev" | "prod";
+        projectId: number;
+        region?: string | undefined;
+        convexToken?: string | undefined;
+        deploymentClass?: string | undefined;
+        reference?: string | undefined;
+    }, any>;
+    requiredAuth: "convexToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        projectId: number;
+        deploymentType?: string | undefined;
+        convexToken?: string | undefined;
+        isDefault?: boolean | undefined;
+        includeLocal?: boolean | undefined;
+    }, any>;
+    requiredAuth: "convexToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        deploymentName: string;
+        convexToken?: string | undefined;
+    }, any>;
+    requiredAuth: "convexToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        deploymentName: string;
+        convexToken?: string | undefined;
+        reference?: string | undefined;
+        dashboardEditConfirmation?: boolean | undefined;
+    }, any>;
+    requiredAuth: "convexToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        deploymentName: string;
+        convexToken?: string | undefined;
+    }, {
+        error: string;
+    } | {
+        success: boolean;
+        deployment_name: string;
+    }>;
+    requiredAuth: "convexToken";
+    scope: "delete";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        name: string;
+        deploymentName: string;
+        convexToken?: string | undefined;
+    }, any>;
+    requiredAuth: "convexToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        domain: string;
+        deploymentName: string;
+        requestDestination: "convexCloud" | "convexSite";
+        convexToken?: string | undefined;
+    }, any>;
+    requiredAuth: "convexToken";
+    scope: "delete";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        convexToken?: string | undefined;
+    }, any>;
+    requiredAuth: "convexToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        deploymentUrl: string;
+        queries: {
+            path: string;
+            args?: Record<string, any> | undefined;
+            format?: string | undefined;
+        }[];
+        convexToken?: string | undefined;
+    }, any>;
+    requiredAuth: "convexToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        deploymentUrl: string;
+        convexToken?: string | undefined;
+    }, any>;
+    requiredAuth: "convexToken";
+    scope: "read";
+})[];
+//# sourceMappingURL=index.d.ts.map

package/dist/toolkits/convex/tools/index.js

@@ -0,0 +1,145 @@
+// @ts-nocheck
+import { convexCreateProject, convexListProjects, convexGetProjectById, convexGetProjectBySlug, convexDeleteProject, } from './projects.js';
+import { convexCreateDeployment, convexListDeployments, convexGetDeployment, convexUpdateDeployment, convexDeleteDeployment, } from './deployments.js';
+import { convexCreateDeployKey, convexListDeployKeys } from './deploy-keys.js';
+import { convexDeleteCustomDomain } from './domains.js';
+import { convexGetTokenDetails, convexListDeploymentClasses, convexListDeploymentRegions, } from './teams.js';
+import { convexExecuteQueryBatch, convexGetQueryTimestamp } from './functions.js';
+import { convexListLogStreams } from './logging.js';
+export { convexCreateProject, convexListProjects, convexGetProjectById, convexGetProjectBySlug, convexDeleteProject, convexCreateDeployment, convexListDeployments, convexGetDeployment, convexUpdateDeployment, convexDeleteDeployment, convexCreateDeployKey, convexListDeployKeys, convexDeleteCustomDomain, convexGetTokenDetails, convexListDeploymentClasses, convexListDeploymentRegions, convexExecuteQueryBatch, convexGetQueryTimestamp, convexListLogStreams, };
+export const convexTools = [
+    {
+        name: 'convexCreateProject',
+        description: convexCreateProject.description,
+        tool: convexCreateProject,
+        requiredAuth: 'convexToken',
+        scope: 'write',
+    },
+    {
+        name: 'convexListProjects',
+        description: convexListProjects.description,
+        tool: convexListProjects,
+        requiredAuth: 'convexToken',
+        scope: 'read',
+    },
+    {
+        name: 'convexGetProjectById',
+        description: convexGetProjectById.description,
+        tool: convexGetProjectById,
+        requiredAuth: 'convexToken',
+        scope: 'read',
+    },
+    {
+        name: 'convexGetProjectBySlug',
+        description: convexGetProjectBySlug.description,
+        tool: convexGetProjectBySlug,
+        requiredAuth: 'convexToken',
+        scope: 'read',
+    },
+    {
+        name: 'convexDeleteProject',
+        description: convexDeleteProject.description,
+        tool: convexDeleteProject,
+        requiredAuth: 'convexToken',
+        scope: 'delete',
+    },
+    {
+        name: 'convexCreateDeployment',
+        description: convexCreateDeployment.description,
+        tool: convexCreateDeployment,
+        requiredAuth: 'convexToken',
+        scope: 'write',
+    },
+    {
+        name: 'convexListDeployments',
+        description: convexListDeployments.description,
+        tool: convexListDeployments,
+        requiredAuth: 'convexToken',
+        scope: 'read',
+    },
+    {
+        name: 'convexGetDeployment',
+        description: convexGetDeployment.description,
+        tool: convexGetDeployment,
+        requiredAuth: 'convexToken',
+        scope: 'read',
+    },
+    {
+        name: 'convexUpdateDeployment',
+        description: convexUpdateDeployment.description,
+        tool: convexUpdateDeployment,
+        requiredAuth: 'convexToken',
+        scope: 'write',
+    },
+    {
+        name: 'convexDeleteDeployment',
+        description: convexDeleteDeployment.description,
+        tool: convexDeleteDeployment,
+        requiredAuth: 'convexToken',
+        scope: 'delete',
+    },
+    {
+        name: 'convexCreateDeployKey',
+        description: convexCreateDeployKey.description,
+        tool: convexCreateDeployKey,
+        requiredAuth: 'convexToken',
+        scope: 'write',
+    },
+    {
+        name: 'convexListDeployKeys',
+        description: convexListDeployKeys.description,
+        tool: convexListDeployKeys,
+        requiredAuth: 'convexToken',
+        scope: 'read',
+    },
+    {
+        name: 'convexDeleteCustomDomain',
+        description: convexDeleteCustomDomain.description,
+        tool: convexDeleteCustomDomain,
+        requiredAuth: 'convexToken',
+        scope: 'delete',
+    },
+    {
+        name: 'convexGetTokenDetails',
+        description: convexGetTokenDetails.description,
+        tool: convexGetTokenDetails,
+        requiredAuth: 'convexToken',
+        scope: 'read',
+    },
+    {
+        name: 'convexListDeploymentClasses',
+        description: convexListDeploymentClasses.description,
+        tool: convexListDeploymentClasses,
+        requiredAuth: 'convexToken',
+        scope: 'read',
+    },
+    {
+        name: 'convexListDeploymentRegions',
+        description: convexListDeploymentRegions.description,
+        tool: convexListDeploymentRegions,
+        requiredAuth: 'convexToken',
+        scope: 'read',
+    },
+    {
+        name: 'convexExecuteQueryBatch',
+        description: convexExecuteQueryBatch.description,
+        tool: convexExecuteQueryBatch,
+        requiredAuth: 'convexToken',
+        scope: 'read',
+    },
+    {
+        name: 'convexGetQueryTimestamp',
+        description: convexGetQueryTimestamp.description,
+        tool: convexGetQueryTimestamp,
+        requiredAuth: 'convexToken',
+        scope: 'read',
+    },
+    {
+        name: 'convexListLogStreams',
+        description: convexListLogStreams.description,
+        tool: convexListLogStreams,
+        requiredAuth: 'convexToken',
+        scope: 'read',
+    },
+];
+//# sourceMappingURL=index.js.map

package/dist/toolkits/convex/tools/logging.d.ts

@@ -0,0 +1,5 @@
+export declare const convexListLogStreams: import("ai").Tool<{
+    deploymentUrl: string;
+    convexToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=logging.d.ts.map

package/dist/toolkits/convex/tools/logging.js

@@ -0,0 +1,25 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { convexDeployment, toConvexError, requireToken } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+export const convexListLogStreams = tool({
+    description: 'List log stream configurations (Datadog, Webhook, Axiom, Sentry) for a deployment, with per-stream status.',
+    inputSchema: z.object({
+        convexToken: tokenField,
+        deploymentUrl: z.string().describe("Full deployment URL, e.g. 'https://quiet-llama-744.convex.cloud'"),
+    }),
+    execute: async ({ convexToken, deploymentUrl }) => {
+        try {
+            const missing = requireToken(convexToken);
+            if (missing)
+                return missing;
+            const data = await convexDeployment(convexToken, deploymentUrl, 'GET', '/api/v1/list_log_streams');
+            return Array.isArray(data) ? { log_streams: data } : data;
+        }
+        catch (error) {
+            return toConvexError(error, 'Failed to list log streams');
+        }
+    },
+});
+//# sourceMappingURL=logging.js.map

package/dist/toolkits/convex/tools/projects.d.ts

@@ -0,0 +1,31 @@
+export declare const convexCreateProject: import("ai").Tool<{
+    teamId: string | number;
+    projectName: string;
+    deploymentType?: string | undefined;
+    convexToken?: string | undefined;
+    deploymentClass?: string | undefined;
+    deploymentRegion?: string | undefined;
+}, any>;
+export declare const convexListProjects: import("ai").Tool<{
+    teamId: string | number;
+    convexToken?: string | undefined;
+}, any>;
+export declare const convexGetProjectById: import("ai").Tool<{
+    projectId: number;
+    convexToken?: string | undefined;
+}, any>;
+export declare const convexGetProjectBySlug: import("ai").Tool<{
+    teamIdOrSlug: string | number;
+    projectSlug: string;
+    convexToken?: string | undefined;
+}, any>;
+export declare const convexDeleteProject: import("ai").Tool<{
+    projectId: number;
+    convexToken?: string | undefined;
+}, {
+    error: string;
+} | {
+    success: boolean;
+    project_id: number;
+}>;
+//# sourceMappingURL=projects.d.ts.map