@rnsk/toolkits 0.0.8 → 0.0.10

package/dist/toolkits/neo4j/tools/projects.js

@@ -0,0 +1,110 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { auraRequest } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+export const neo4jGetProject = tool({
+    description: 'Get an Aura project (tenant) by ID, including available instance configurations (regions, types, memory, storage, providers). Use before creating an instance.',
+    inputSchema: z.object({
+        neo4jCredentials: tokenField,
+        tenantId: z.string().describe('Project/tenant ID'),
+    }),
+    execute: async ({ neo4jCredentials, tenantId }) => {
+        return auraRequest(neo4jCredentials, `/v1/tenants/${encodeURIComponent(tenantId)}`);
+    },
+});
+export const neo4jGetProjectBeta = tool({
+    description: 'Get an Aura project (tenant) by ID via v1beta5, including instance configurations. May expose newer fields than v1.',
+    inputSchema: z.object({
+        neo4jCredentials: tokenField,
+        tenantId: z.string().describe('Project/tenant ID'),
+    }),
+    execute: async ({ neo4jCredentials, tenantId }) => {
+        return auraRequest(neo4jCredentials, `/v1beta5/tenants/${encodeURIComponent(tenantId)}`);
+    },
+});
+export const neo4jListProjects = tool({
+    description: 'List all Aura projects (tenants) with ID and name. Use to discover accessible projects.',
+    inputSchema: z.object({
+        neo4jCredentials: tokenField,
+    }),
+    execute: async ({ neo4jCredentials }) => {
+        return auraRequest(neo4jCredentials, '/v1/tenants');
+    },
+});
+export const neo4jListProjectUsers = tool({
+    description: 'List users in an Aura project with email, ID, and project roles. Use to audit team access.',
+    inputSchema: z.object({
+        neo4jCredentials: tokenField,
+        organizationId: z.string().describe('Organization ID'),
+        projectId: z.string().describe('Project ID'),
+    }),
+    execute: async ({ neo4jCredentials, organizationId, projectId }) => {
+        return auraRequest(neo4jCredentials, `/v1/organizations/${encodeURIComponent(organizationId)}/projects/${encodeURIComponent(projectId)}/users`);
+    },
+});
+export const neo4jGetOrganizationUser = tool({
+    description: 'Get an Aura organization user by ID: email, org roles, MFA status, last activity, project access. Use to verify membership or permissions.',
+    inputSchema: z.object({
+        neo4jCredentials: tokenField,
+        organizationId: z.string().describe('Organization ID'),
+        userId: z.string().describe('User ID'),
+    }),
+    execute: async ({ neo4jCredentials, organizationId, userId }) => {
+        return auraRequest(neo4jCredentials, `/v1/organizations/${encodeURIComponent(organizationId)}/users/${encodeURIComponent(userId)}`);
+    },
+});
+export const neo4jListIpFilters = tool({
+    description: 'List IP filters of an Aura organization with CIDR allow lists and filtered entities. Use to audit network access rules.',
+    inputSchema: z.object({
+        neo4jCredentials: tokenField,
+        organizationId: z.string().describe('Organization ID'),
+    }),
+    execute: async ({ neo4jCredentials, organizationId }) => {
+        return auraRequest(neo4jCredentials, `/v1/organizations/${encodeURIComponent(organizationId)}/ip-filters`);
+    },
+});
+const allowEntry = z.object({
+    address: z.string().describe('IP address or CIDR block'),
+    prefixLen: z.number().int().min(0).max(128).describe('CIDR prefix length'),
+    description: z.string().optional().describe('Entry description'),
+});
+export const neo4jUpdateIpFilter = tool({
+    description: 'Partially update an Aura organization IP filter: name, description, allow list, or enable/disable. Only provided fields change.',
+    inputSchema: z.object({
+        neo4jCredentials: tokenField,
+        organizationId: z.string().describe('Organization ID'),
+        ipFilterId: z.string().describe('IP filter ID'),
+        name: z.string().optional().describe('New filter name'),
+        description: z.string().optional().describe('New filter description'),
+        allowList: z.array(allowEntry).optional().describe('Replacement CIDR allow list'),
+        filteringDisabled: z.boolean().optional().describe('True disables filtering (allows all traffic)'),
+    }),
+    execute: async ({ neo4jCredentials, organizationId, ipFilterId, name, description, allowList, filteringDisabled }) => {
+        return auraRequest(neo4jCredentials, `/v1/organizations/${encodeURIComponent(organizationId)}/ip-filters/${encodeURIComponent(ipFilterId)}`, {
+            method: 'PATCH',
+            body: {
+                name,
+                description,
+                allow_list: allowList?.map((e) => ({
+                    address: e.address,
+                    prefix_len: e.prefixLen,
+                    description: e.description,
+                })),
+                filtering_disabled: filteringDisabled,
+            },
+        });
+    },
+});
+export const neo4jListAgents = tool({
+    description: 'List Aura agents in a project with ID, name, database, privacy, endpoints, MCP status, and tools. Use to discover available agents.',
+    inputSchema: z.object({
+        neo4jCredentials: tokenField,
+        organizationId: z.string().describe('Organization ID'),
+        projectId: z.string().describe('Project ID'),
+    }),
+    execute: async ({ neo4jCredentials, organizationId, projectId }) => {
+        return auraRequest(neo4jCredentials, `/v1/organizations/${encodeURIComponent(organizationId)}/projects/${encodeURIComponent(projectId)}/agents`);
+    },
+});
+//# sourceMappingURL=projects.js.map

package/dist/toolkits/neo4j/tools/snapshots.d.ts

@@ -0,0 +1,20 @@
+export declare const neo4jCreateSnapshot: import("ai").Tool<{
+    instanceId: string;
+    neo4jCredentials?: string | undefined;
+}, any>;
+export declare const neo4jGetSnapshot: import("ai").Tool<{
+    instanceId: string;
+    snapshotId: string;
+    neo4jCredentials?: string | undefined;
+}, any>;
+export declare const neo4jListSnapshots: import("ai").Tool<{
+    instanceId: string;
+    date?: string | undefined;
+    neo4jCredentials?: string | undefined;
+}, any>;
+export declare const neo4jRestoreSnapshot: import("ai").Tool<{
+    instanceId: string;
+    snapshotId: string;
+    neo4jCredentials?: string | undefined;
+}, any>;
+//# sourceMappingURL=snapshots.d.ts.map

package/dist/toolkits/neo4j/tools/snapshots.js

@@ -0,0 +1,57 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { auraRequest } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+const instanceIdField = z.string().describe('Aura instance ID');
+export const neo4jCreateSnapshot = tool({
+    description: 'Create an on-demand snapshot (backup) of a Neo4j Aura instance. Asynchronous; use the returned snapshot ID to monitor progress. Snapshot before migrations or bulk updates.',
+    inputSchema: z.object({
+        neo4jCredentials: tokenField,
+        instanceId: instanceIdField,
+    }),
+    execute: async ({ neo4jCredentials, instanceId }) => {
+        return auraRequest(neo4jCredentials, `/v1/instances/${encodeURIComponent(instanceId)}/snapshots`, {
+            method: 'POST',
+        });
+    },
+});
+export const neo4jGetSnapshot = tool({
+    description: 'Get details of a specific Aura snapshot: profile, status, creation timestamp. Use to check backup progress.',
+    inputSchema: z.object({
+        neo4jCredentials: tokenField,
+        instanceId: instanceIdField,
+        snapshotId: z.string().describe('Snapshot ID'),
+    }),
+    execute: async ({ neo4jCredentials, instanceId, snapshotId }) => {
+        return auraRequest(neo4jCredentials, `/v1/instances/${encodeURIComponent(instanceId)}/snapshots/${encodeURIComponent(snapshotId)}`);
+    },
+});
+export const neo4jListSnapshots = tool({
+    description: 'List scheduled and on-demand snapshots for an Aura instance with status and timestamps. Optionally filter to a single day.',
+    inputSchema: z.object({
+        neo4jCredentials: tokenField,
+        instanceId: instanceIdField,
+        date: z.string().optional().describe('Filter to a day, YYYY-MM-DD. Defaults to today.'),
+    }),
+    execute: async ({ neo4jCredentials, instanceId, date }) => {
+        return auraRequest(neo4jCredentials, `/v1/instances/${encodeURIComponent(instanceId)}/snapshots`, {
+            query: { date },
+        });
+    },
+});
+export const neo4jRestoreSnapshot = tool({
+    description: 'Restore an Aura instance from a snapshot, replacing all current data. IRREVERSIBLE: data since the snapshot is permanently lost. Confirm with the user first.',
+    inputSchema: z.object({
+        neo4jCredentials: tokenField,
+        instanceId: instanceIdField,
+        snapshotId: z.string().describe('Snapshot ID to restore from'),
+    }),
+    execute: async ({ neo4jCredentials, instanceId, snapshotId }) => {
+        return auraRequest(neo4jCredentials, `/v1/instances/${encodeURIComponent(instanceId)}/restore`, {
+            method: 'POST',
+            body: { snapshot_id: snapshotId },
+        });
+    },
+});
+//# sourceMappingURL=snapshots.js.map

package/dist/toolkits/neon/icon.d.ts

@@ -0,0 +1,5 @@
+export declare const NEON_ICON: {
+    kind: "svg";
+    dataUri: string;
+};
+//# sourceMappingURL=icon.d.ts.map

package/dist/toolkits/neon/icon.js

@@ -0,0 +1,8 @@
+const SVG = `<svg width="64" height="64" viewBox="0 0 64 64" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M63 0.0177909V63.5526L38.4178 42.2501V63.5526H0V0L63 0.0177909ZM7.72251 55.8389H30.6953V25.3238L55.2779 47.0476V7.72922L7.72251 7.71559V55.8389Z" fill="#34D59A"/>
+</svg>`;
+export const NEON_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

package/dist/toolkits/neon/manifest.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("../../index.js").ToolkitManifest;
+export default _default;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/toolkits/neon/manifest.js

@@ -0,0 +1,36 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { inferToolScope } from '../../core/scope.js';
+import { NEON_ICON } from './icon.js';
+import { neonTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'neon',
+    displayName: 'Neon',
+    shortDescription: 'Serverless Postgres projects, branches, databases, endpoints, auth, and orgs.',
+    category: 'Data & Analytics',
+    icon: NEON_ICON,
+    auth: {
+        type: 'api_key',
+        tokenField: 'neonApiKey',
+        provider: {
+            in: 'header',
+            name: 'Authorization',
+            prefix: 'Bearer',
+            connectDescription: 'Connect Neon with an API key. Create one in the Neon Console under Account Settings > API keys. All calls send it as Authorization: Bearer <key> to console.neon.tech/api/v2.',
+        },
+    },
+    allowedHosts: ['console.neon.tech'],
+    tools: neonTools.map((entry) => defineTool({
+        name: entry.name,
+        description: entry.description,
+        tool: entry.tool,
+        requiredAuth: entry.requiredAuth,
+        scope: entry.scope ?? inferToolScope(entry.name),
+    })),
+    meta: {
+        since: '0.0.9',
+        homepage: 'https://neon.com',
+        docsUrl: 'https://neon.com/docs/reference/api',
+        apiDocsUrl: 'https://api-docs.neon.tech/reference/getting-started-with-neon-api',
+    },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/toolkits/neon/tools/auth.d.ts

@@ -0,0 +1,115 @@
+export declare const neonCreateAuthKeys: import("ai").Tool<{
+    projectId: string;
+    authProvider: "mock" | "stack" | "stack_v2" | "better_auth";
+    neonApiKey?: string | undefined;
+}, any>;
+export declare const neonCreateAuthUser: import("ai").Tool<{
+    projectId: string;
+    name: string;
+    email: string;
+    branchId: string;
+    neonApiKey?: string | undefined;
+}, any>;
+export declare const neonCreateBranchesAuth: import("ai").Tool<{
+    projectId: string;
+    branchId: string;
+    authProvider: "mock" | "stack" | "stack_v2" | "better_auth";
+    neonApiKey?: string | undefined;
+    databaseName?: string | undefined;
+}, any>;
+export declare const neonDeleteAuthDomainFromProject: import("ai").Tool<{
+    projectId: string;
+    domains: Record<string, any>[];
+    authProvider: "mock" | "stack" | "stack_v2" | "better_auth";
+    neonApiKey?: string | undefined;
+}, any>;
+export declare const neonDeleteAuthDomains: import("ai").Tool<{
+    projectId: string;
+    domains: Record<string, any>[];
+    branchId: string;
+    authProvider: "mock" | "stack" | "stack_v2" | "better_auth";
+    neonApiKey?: string | undefined;
+}, any>;
+export declare const neonDeleteAuthOauthProvider: import("ai").Tool<{
+    projectId: string;
+    branchId: string;
+    oauthProviderId: "github" | "google" | "vercel";
+    neonApiKey?: string | undefined;
+}, any>;
+export declare const neonDeleteAuthUser: import("ai").Tool<{
+    projectId: string;
+    branchId: string;
+    authUserId: string;
+    neonApiKey?: string | undefined;
+}, any>;
+export declare const neonDisableBranchesAuth: import("ai").Tool<{
+    projectId: string;
+    branchId: string;
+    neonApiKey?: string | undefined;
+    deleteData?: boolean | undefined;
+}, any>;
+export declare const neonGetAuth: import("ai").Tool<{
+    neonApiKey?: string | undefined;
+}, any>;
+export declare const neonGetAuthAllowLocalhost: import("ai").Tool<{
+    projectId: string;
+    branchId: string;
+    neonApiKey?: string | undefined;
+}, any>;
+export declare const neonGetAuthEmailProvider: import("ai").Tool<{
+    projectId: string;
+    branchId: string;
+    neonApiKey?: string | undefined;
+}, any>;
+export declare const neonListAuthDomains: import("ai").Tool<{
+    projectId: string;
+    branchId: string;
+    neonApiKey?: string | undefined;
+}, any>;
+export declare const neonListAuthOauthProviders: import("ai").Tool<{
+    projectId: string;
+    neonApiKey?: string | undefined;
+}, any>;
+export declare const neonListAuthOauthProviders2: import("ai").Tool<{
+    projectId: string;
+    branchId: string;
+    neonApiKey?: string | undefined;
+}, any>;
+export declare const neonSendAuthTestEmail: import("ai").Tool<{
+    projectId: string;
+    username: string;
+    branchId: string;
+    host: string;
+    port: number;
+    password: string;
+    senderName: string;
+    senderEmail: string;
+    recipientEmail: string;
+    neonApiKey?: string | undefined;
+}, any>;
+export declare const neonUpdateAuthAllowLocalhost: import("ai").Tool<{
+    projectId: string;
+    branchId: string;
+    allowLocalhost: boolean;
+    neonApiKey?: string | undefined;
+}, any>;
+export declare const neonUpdateAuthEmailProvider: import("ai").Tool<{
+    projectId: string;
+    branchId: string;
+    senderName: string;
+    senderEmail: string;
+    username?: string | undefined;
+    neonApiKey?: string | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    password?: string | undefined;
+}, any>;
+export declare const neonUpdateAuthOauthProviders: import("ai").Tool<{
+    projectId: string;
+    oauthProviderId: "github" | "google" | "vercel" | "microsoft";
+    clientId?: string | undefined;
+    clientSecret?: string | undefined;
+    neonApiKey?: string | undefined;
+    microsoftTenantId?: string | undefined;
+}, any>;
+//# sourceMappingURL=auth.d.ts.map