@rnsk/toolkits 0.0.5 → 0.0.6

package/dist/toolkits/aws/tools/ec2/get-instance.d.ts

@@ -0,0 +1,65 @@
+export declare const awsGetEc2Instance: import("ai").Tool<{
+    instanceId: string;
+    region?: string | undefined;
+    awsCredentials?: string | undefined;
+}, {
+    error: string;
+    instanceId?: undefined;
+    instanceType?: undefined;
+    state?: undefined;
+    privateIpAddress?: undefined;
+    publicIpAddress?: undefined;
+    launchTime?: undefined;
+    availabilityZone?: undefined;
+    vpcId?: undefined;
+    subnetId?: undefined;
+    securityGroups?: undefined;
+    tags?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    instanceId: string;
+    instanceType?: undefined;
+    state?: undefined;
+    privateIpAddress?: undefined;
+    publicIpAddress?: undefined;
+    launchTime?: undefined;
+    availabilityZone?: undefined;
+    vpcId?: undefined;
+    subnetId?: undefined;
+    securityGroups?: undefined;
+    tags?: undefined;
+    message?: undefined;
+} | {
+    instanceId: string | undefined;
+    instanceType: import("@aws-sdk/client-ec2")._InstanceType | undefined;
+    state: import("@aws-sdk/client-ec2").InstanceStateName | undefined;
+    privateIpAddress: string | undefined;
+    publicIpAddress: string | undefined;
+    launchTime: Date | undefined;
+    availabilityZone: string | undefined;
+    vpcId: string | undefined;
+    subnetId: string | undefined;
+    securityGroups: {
+        id: string | undefined;
+        name: string | undefined;
+    }[];
+    tags: Record<string, string>;
+    error?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    instanceId?: undefined;
+    instanceType?: undefined;
+    state?: undefined;
+    privateIpAddress?: undefined;
+    publicIpAddress?: undefined;
+    launchTime?: undefined;
+    availabilityZone?: undefined;
+    vpcId?: undefined;
+    subnetId?: undefined;
+    securityGroups?: undefined;
+    tags?: undefined;
+}>;
+//# sourceMappingURL=get-instance.d.ts.map

package/dist/toolkits/aws/tools/ec2/get-instance.js

@@ -0,0 +1,46 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { DescribeInstancesCommand } from '@aws-sdk/client-ec2';
+import { createEc2Client } from '../client.js';
+export const awsGetEc2Instance = tool({
+    description: 'Get detailed information about a specific EC2 instance by instance ID.',
+    inputSchema: z.object({
+        awsCredentials: z.string().optional().describe('Injected by system; do not provide'),
+        region: z.string().optional().describe('AWS region to query (default: us-east-1)'),
+        instanceId: z.string().describe('The EC2 instance ID (e.g. i-0123456789abcdef0)'),
+    }),
+    execute: async ({ awsCredentials, region, instanceId }) => {
+        if (!awsCredentials) {
+            return { error: 'AWS credentials are required. Connect AWS first.' };
+        }
+        try {
+            const client = createEc2Client(awsCredentials, region);
+            const response = await client.send(new DescribeInstancesCommand({ InstanceIds: [instanceId] }));
+            const instance = response.Reservations?.[0]?.Instances?.[0];
+            if (!instance) {
+                return { error: 'Instance not found', instanceId };
+            }
+            return {
+                instanceId: instance.InstanceId,
+                instanceType: instance.InstanceType,
+                state: instance.State?.Name,
+                privateIpAddress: instance.PrivateIpAddress,
+                publicIpAddress: instance.PublicIpAddress,
+                launchTime: instance.LaunchTime,
+                availabilityZone: instance.Placement?.AvailabilityZone,
+                vpcId: instance.VpcId,
+                subnetId: instance.SubnetId,
+                securityGroups: (instance.SecurityGroups ?? []).map((sg) => ({ id: sg.GroupId, name: sg.GroupName })),
+                tags: (instance.Tags ?? []).reduce((acc, tag) => {
+                    if (tag.Key && tag.Value)
+                        acc[tag.Key] = tag.Value;
+                    return acc;
+                }, {}),
+            };
+        }
+        catch (err) {
+            return { error: 'Failed to get EC2 instance', message: err instanceof Error ? err.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=get-instance.js.map

package/dist/toolkits/aws/tools/ec2/list-instances.d.ts

@@ -0,0 +1,30 @@
+export declare const awsListEc2Instances: import("ai").Tool<{
+    maxResults?: number | undefined;
+    region?: string | undefined;
+    awsCredentials?: string | undefined;
+    stateFilter?: "pending" | "running" | "shutting-down" | "terminated" | "stopping" | "stopped" | undefined;
+}, {
+    error: string;
+    count?: undefined;
+    instances?: undefined;
+    message?: undefined;
+} | {
+    count: number;
+    instances: {
+        instanceId: string | undefined;
+        instanceType: import("@aws-sdk/client-ec2")._InstanceType | undefined;
+        state: import("@aws-sdk/client-ec2").InstanceStateName | undefined;
+        privateIpAddress: string | undefined;
+        publicIpAddress: string | undefined;
+        launchTime: Date | undefined;
+        tags: Record<string, string>;
+    }[];
+    error?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    count?: undefined;
+    instances?: undefined;
+}>;
+//# sourceMappingURL=list-instances.d.ts.map

package/dist/toolkits/aws/tools/ec2/list-instances.js

@@ -0,0 +1,46 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { DescribeInstancesCommand } from '@aws-sdk/client-ec2';
+import { createEc2Client } from '../client.js';
+export const awsListEc2Instances = tool({
+    description: 'List EC2 instances in the connected AWS account, optionally filtered by instance state. Returns instance ID, type, state, IPs, and tags.',
+    inputSchema: z.object({
+        awsCredentials: z.string().optional().describe('Injected by system; do not provide'),
+        region: z.string().optional().describe('AWS region to query (default: us-east-1)'),
+        stateFilter: z
+            .enum(['pending', 'running', 'shutting-down', 'terminated', 'stopping', 'stopped'])
+            .optional()
+            .describe('Only return instances in this state'),
+        maxResults: z.number().min(5).max(1000).optional().describe('Maximum number of instances to return'),
+    }),
+    execute: async ({ awsCredentials, region, stateFilter, maxResults }) => {
+        if (!awsCredentials) {
+            return { error: 'AWS credentials are required. Connect AWS first.' };
+        }
+        try {
+            const client = createEc2Client(awsCredentials, region);
+            const response = await client.send(new DescribeInstancesCommand({
+                Filters: stateFilter ? [{ Name: 'instance-state-name', Values: [stateFilter] }] : undefined,
+                MaxResults: maxResults,
+            }));
+            const instances = (response.Reservations ?? []).flatMap((reservation) => (reservation.Instances ?? []).map((instance) => ({
+                instanceId: instance.InstanceId,
+                instanceType: instance.InstanceType,
+                state: instance.State?.Name,
+                privateIpAddress: instance.PrivateIpAddress,
+                publicIpAddress: instance.PublicIpAddress,
+                launchTime: instance.LaunchTime,
+                tags: (instance.Tags ?? []).reduce((acc, tag) => {
+                    if (tag.Key && tag.Value)
+                        acc[tag.Key] = tag.Value;
+                    return acc;
+                }, {}),
+            })));
+            return { count: instances.length, instances };
+        }
+        catch (err) {
+            return { error: 'Failed to list EC2 instances', message: err instanceof Error ? err.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=list-instances.js.map

package/dist/toolkits/aws/tools/ec2/start-instance.d.ts

@@ -0,0 +1,24 @@
+export declare const awsStartEc2Instance: import("ai").Tool<{
+    instanceId: string;
+    region?: string | undefined;
+    awsCredentials?: string | undefined;
+}, {
+    error: string;
+    instanceId?: undefined;
+    currentState?: undefined;
+    previousState?: undefined;
+    message?: undefined;
+} | {
+    instanceId: string;
+    currentState: import("@aws-sdk/client-ec2").InstanceStateName | undefined;
+    previousState: import("@aws-sdk/client-ec2").InstanceStateName | undefined;
+    error?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    instanceId?: undefined;
+    currentState?: undefined;
+    previousState?: undefined;
+}>;
+//# sourceMappingURL=start-instance.d.ts.map

package/dist/toolkits/aws/tools/ec2/start-instance.js

@@ -0,0 +1,31 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { StartInstancesCommand } from '@aws-sdk/client-ec2';
+import { createEc2Client } from '../client.js';
+export const awsStartEc2Instance = tool({
+    description: 'Start a stopped EC2 instance.',
+    inputSchema: z.object({
+        awsCredentials: z.string().optional().describe('Injected by system; do not provide'),
+        region: z.string().optional().describe('AWS region the instance is in (default: us-east-1)'),
+        instanceId: z.string().describe('The EC2 instance ID to start'),
+    }),
+    execute: async ({ awsCredentials, region, instanceId }) => {
+        if (!awsCredentials) {
+            return { error: 'AWS credentials are required. Connect AWS first.' };
+        }
+        try {
+            const client = createEc2Client(awsCredentials, region);
+            const response = await client.send(new StartInstancesCommand({ InstanceIds: [instanceId] }));
+            const status = response.StartingInstances?.[0];
+            return {
+                instanceId,
+                currentState: status?.CurrentState?.Name,
+                previousState: status?.PreviousState?.Name,
+            };
+        }
+        catch (err) {
+            return { error: 'Failed to start EC2 instance', message: err instanceof Error ? err.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=start-instance.js.map

package/dist/toolkits/aws/tools/ec2/stop-instance.d.ts

@@ -0,0 +1,24 @@
+export declare const awsStopEc2Instance: import("ai").Tool<{
+    instanceId: string;
+    region?: string | undefined;
+    awsCredentials?: string | undefined;
+}, {
+    error: string;
+    instanceId?: undefined;
+    currentState?: undefined;
+    previousState?: undefined;
+    message?: undefined;
+} | {
+    instanceId: string;
+    currentState: import("@aws-sdk/client-ec2").InstanceStateName | undefined;
+    previousState: import("@aws-sdk/client-ec2").InstanceStateName | undefined;
+    error?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    instanceId?: undefined;
+    currentState?: undefined;
+    previousState?: undefined;
+}>;
+//# sourceMappingURL=stop-instance.d.ts.map

package/dist/toolkits/aws/tools/ec2/stop-instance.js

@@ -0,0 +1,31 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { StopInstancesCommand } from '@aws-sdk/client-ec2';
+import { createEc2Client } from '../client.js';
+export const awsStopEc2Instance = tool({
+    description: 'Stop a running EC2 instance.',
+    inputSchema: z.object({
+        awsCredentials: z.string().optional().describe('Injected by system; do not provide'),
+        region: z.string().optional().describe('AWS region the instance is in (default: us-east-1)'),
+        instanceId: z.string().describe('The EC2 instance ID to stop'),
+    }),
+    execute: async ({ awsCredentials, region, instanceId }) => {
+        if (!awsCredentials) {
+            return { error: 'AWS credentials are required. Connect AWS first.' };
+        }
+        try {
+            const client = createEc2Client(awsCredentials, region);
+            const response = await client.send(new StopInstancesCommand({ InstanceIds: [instanceId] }));
+            const status = response.StoppingInstances?.[0];
+            return {
+                instanceId,
+                currentState: status?.CurrentState?.Name,
+                previousState: status?.PreviousState?.Name,
+            };
+        }
+        catch (err) {
+            return { error: 'Failed to stop EC2 instance', message: err instanceof Error ? err.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=stop-instance.js.map

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

@@ -0,0 +1,273 @@
+import { awsListEc2Instances } from './ec2/list-instances.js';
+import { awsGetEc2Instance } from './ec2/get-instance.js';
+import { awsStartEc2Instance } from './ec2/start-instance.js';
+import { awsStopEc2Instance } from './ec2/stop-instance.js';
+import { awsGetCloudwatchMetricData } from './cloudwatch/get-metric-data.js';
+import { awsListCloudwatchAlarms } from './cloudwatch/list-alarms.js';
+import { awsListCloudwatchLogGroups } from './cloudwatch/list-log-groups.js';
+import { awsFilterCloudwatchLogEvents } from './cloudwatch/filter-log-events.js';
+export { awsListEc2Instances, awsGetEc2Instance, awsStartEc2Instance, awsStopEc2Instance, awsGetCloudwatchMetricData, awsListCloudwatchAlarms, awsListCloudwatchLogGroups, awsFilterCloudwatchLogEvents, };
+export declare const awsTools: ({
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        maxResults?: number | undefined;
+        region?: string | undefined;
+        awsCredentials?: string | undefined;
+        stateFilter?: "pending" | "running" | "shutting-down" | "terminated" | "stopping" | "stopped" | undefined;
+    }, {
+        error: string;
+        count?: undefined;
+        instances?: undefined;
+        message?: undefined;
+    } | {
+        count: number;
+        instances: {
+            instanceId: string | undefined;
+            instanceType: import("@aws-sdk/client-ec2")._InstanceType | undefined;
+            state: import("@aws-sdk/client-ec2").InstanceStateName | undefined;
+            privateIpAddress: string | undefined;
+            publicIpAddress: string | undefined;
+            launchTime: Date | undefined;
+            tags: Record<string, string>;
+        }[];
+        error?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        count?: undefined;
+        instances?: undefined;
+    }>;
+    requiredAuth: "awsCredentials";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        instanceId: string;
+        region?: string | undefined;
+        awsCredentials?: string | undefined;
+    }, {
+        error: string;
+        instanceId?: undefined;
+        instanceType?: undefined;
+        state?: undefined;
+        privateIpAddress?: undefined;
+        publicIpAddress?: undefined;
+        launchTime?: undefined;
+        availabilityZone?: undefined;
+        vpcId?: undefined;
+        subnetId?: undefined;
+        securityGroups?: undefined;
+        tags?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        instanceId: string;
+        instanceType?: undefined;
+        state?: undefined;
+        privateIpAddress?: undefined;
+        publicIpAddress?: undefined;
+        launchTime?: undefined;
+        availabilityZone?: undefined;
+        vpcId?: undefined;
+        subnetId?: undefined;
+        securityGroups?: undefined;
+        tags?: undefined;
+        message?: undefined;
+    } | {
+        instanceId: string | undefined;
+        instanceType: import("@aws-sdk/client-ec2")._InstanceType | undefined;
+        state: import("@aws-sdk/client-ec2").InstanceStateName | undefined;
+        privateIpAddress: string | undefined;
+        publicIpAddress: string | undefined;
+        launchTime: Date | undefined;
+        availabilityZone: string | undefined;
+        vpcId: string | undefined;
+        subnetId: string | undefined;
+        securityGroups: {
+            id: string | undefined;
+            name: string | undefined;
+        }[];
+        tags: Record<string, string>;
+        error?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        instanceId?: undefined;
+        instanceType?: undefined;
+        state?: undefined;
+        privateIpAddress?: undefined;
+        publicIpAddress?: undefined;
+        launchTime?: undefined;
+        availabilityZone?: undefined;
+        vpcId?: undefined;
+        subnetId?: undefined;
+        securityGroups?: undefined;
+        tags?: undefined;
+    }>;
+    requiredAuth: "awsCredentials";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        instanceId: string;
+        region?: string | undefined;
+        awsCredentials?: string | undefined;
+    }, {
+        error: string;
+        instanceId?: undefined;
+        currentState?: undefined;
+        previousState?: undefined;
+        message?: undefined;
+    } | {
+        instanceId: string;
+        currentState: import("@aws-sdk/client-ec2").InstanceStateName | undefined;
+        previousState: import("@aws-sdk/client-ec2").InstanceStateName | undefined;
+        error?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        instanceId?: undefined;
+        currentState?: undefined;
+        previousState?: undefined;
+    }>;
+    requiredAuth: "awsCredentials";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        namespace: string;
+        metricName: string;
+        region?: string | undefined;
+        awsCredentials?: string | undefined;
+        dimensions?: Record<string, string> | undefined;
+        startTime?: string | undefined;
+        endTime?: string | undefined;
+        period?: number | undefined;
+        statistic?: "Average" | "Sum" | "Minimum" | "Maximum" | "SampleCount" | undefined;
+    }, {
+        error: string;
+        label?: undefined;
+        datapoints?: undefined;
+        message?: undefined;
+    } | {
+        label: string | undefined;
+        datapoints: {
+            timestamp: Date | undefined;
+            average: number | undefined;
+            sum: number | undefined;
+            minimum: number | undefined;
+            maximum: number | undefined;
+            sampleCount: number | undefined;
+            unit: import("@aws-sdk/client-cloudwatch").StandardUnit | undefined;
+        }[];
+        error?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        label?: undefined;
+        datapoints?: undefined;
+    }>;
+    requiredAuth: "awsCredentials";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        region?: string | undefined;
+        awsCredentials?: string | undefined;
+        alarmNamePrefix?: string | undefined;
+        stateValue?: "OK" | "ALARM" | "INSUFFICIENT_DATA" | undefined;
+        maxRecords?: number | undefined;
+    }, {
+        error: string;
+        alarms?: undefined;
+        message?: undefined;
+    } | {
+        alarms: {
+            alarmName: string | undefined;
+            alarmArn: string | undefined;
+            stateValue: import("@aws-sdk/client-cloudwatch").StateValue | undefined;
+            stateReason: string | undefined;
+            metricName: string | undefined;
+            namespace: string | undefined;
+            threshold: number | undefined;
+            comparisonOperator: import("@aws-sdk/client-cloudwatch").ComparisonOperator | undefined;
+        }[];
+        error?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        alarms?: undefined;
+    }>;
+    requiredAuth: "awsCredentials";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        limit?: number | undefined;
+        region?: string | undefined;
+        awsCredentials?: string | undefined;
+        logGroupNamePrefix?: string | undefined;
+    }, {
+        error: string;
+        logGroups?: undefined;
+        message?: undefined;
+    } | {
+        logGroups: {
+            logGroupName: string | undefined;
+            creationTime: number | undefined;
+            retentionInDays: number | undefined;
+            storedBytes: number | undefined;
+            arn: string | undefined;
+        }[];
+        error?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        logGroups?: undefined;
+    }>;
+    requiredAuth: "awsCredentials";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        logGroupName: string;
+        limit?: number | undefined;
+        region?: string | undefined;
+        awsCredentials?: string | undefined;
+        startTime?: number | undefined;
+        endTime?: number | undefined;
+        filterPattern?: string | undefined;
+    }, {
+        error: string;
+        events?: undefined;
+        message?: undefined;
+    } | {
+        events: {
+            logStreamName: string | undefined;
+            timestamp: number | undefined;
+            message: string | undefined;
+        }[];
+        error?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        events?: undefined;
+    }>;
+    requiredAuth: "awsCredentials";
+    scope: "read";
+})[];
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,68 @@
+import { awsListEc2Instances } from './ec2/list-instances.js';
+import { awsGetEc2Instance } from './ec2/get-instance.js';
+import { awsStartEc2Instance } from './ec2/start-instance.js';
+import { awsStopEc2Instance } from './ec2/stop-instance.js';
+import { awsGetCloudwatchMetricData } from './cloudwatch/get-metric-data.js';
+import { awsListCloudwatchAlarms } from './cloudwatch/list-alarms.js';
+import { awsListCloudwatchLogGroups } from './cloudwatch/list-log-groups.js';
+import { awsFilterCloudwatchLogEvents } from './cloudwatch/filter-log-events.js';
+export { awsListEc2Instances, awsGetEc2Instance, awsStartEc2Instance, awsStopEc2Instance, awsGetCloudwatchMetricData, awsListCloudwatchAlarms, awsListCloudwatchLogGroups, awsFilterCloudwatchLogEvents, };
+export const awsTools = [
+    {
+        name: 'awsListEc2Instances',
+        description: 'List EC2 instances, optionally filtered by state.',
+        tool: awsListEc2Instances,
+        requiredAuth: 'awsCredentials',
+        scope: 'read',
+    },
+    {
+        name: 'awsGetEc2Instance',
+        description: 'Get detailed information about a specific EC2 instance.',
+        tool: awsGetEc2Instance,
+        requiredAuth: 'awsCredentials',
+        scope: 'read',
+    },
+    {
+        name: 'awsStartEc2Instance',
+        description: 'Start a stopped EC2 instance.',
+        tool: awsStartEc2Instance,
+        requiredAuth: 'awsCredentials',
+        scope: 'write',
+    },
+    {
+        name: 'awsStopEc2Instance',
+        description: 'Stop a running EC2 instance.',
+        tool: awsStopEc2Instance,
+        requiredAuth: 'awsCredentials',
+        scope: 'write',
+    },
+    {
+        name: 'awsGetCloudwatchMetricData',
+        description: 'Retrieve CloudWatch metric statistics for a namespace and metric name.',
+        tool: awsGetCloudwatchMetricData,
+        requiredAuth: 'awsCredentials',
+        scope: 'read',
+    },
+    {
+        name: 'awsListCloudwatchAlarms',
+        description: 'List CloudWatch alarms, optionally filtered by name prefix or state.',
+        tool: awsListCloudwatchAlarms,
+        requiredAuth: 'awsCredentials',
+        scope: 'read',
+    },
+    {
+        name: 'awsListCloudwatchLogGroups',
+        description: 'List CloudWatch log groups, optionally filtered by name prefix.',
+        tool: awsListCloudwatchLogGroups,
+        requiredAuth: 'awsCredentials',
+        scope: 'read',
+    },
+    {
+        name: 'awsFilterCloudwatchLogEvents',
+        description: 'Search CloudWatch log events with an optional filter pattern and time range.',
+        tool: awsFilterCloudwatchLogEvents,
+        requiredAuth: 'awsCredentials',
+        scope: 'read',
+    },
+];
+//# sourceMappingURL=index.js.map

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

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