veryfront 0.0.49 → 0.0.51

package/dist/integrations/aws/files/lib/aws-client.ts

@@ -0,0 +1,255 @@
+import { S3Client, ListBucketsCommand, ListObjectsV2Command, GetObjectCommand } from '@aws-sdk/client-s3';
+import { EC2Client, DescribeInstancesCommand } from '@aws-sdk/client-ec2';
+import { LambdaClient, ListFunctionsCommand } from '@aws-sdk/client-lambda';
+import { fromEnv } from '@aws-sdk/credential-providers';
+
+/**
+ * AWS Client Configuration
+ */
+interface AWSClientConfig {
+  region?: string;
+  accessKeyId?: string;
+  secretAccessKey?: string;
+}
+
+/**
+ * S3 Bucket Information
+ */
+export interface S3Bucket {
+  name: string;
+  creationDate?: Date;
+}
+
+/**
+ * S3 Object Information
+ */
+export interface S3Object {
+  key: string;
+  size: number;
+  lastModified?: Date;
+  etag?: string;
+  storageClass?: string;
+}
+
+/**
+ * EC2 Instance Information
+ */
+export interface EC2Instance {
+  instanceId: string;
+  instanceType: string;
+  state: string;
+  publicIpAddress?: string;
+  privateIpAddress?: string;
+  launchTime?: Date;
+  name?: string;
+  availabilityZone?: string;
+}
+
+/**
+ * Lambda Function Information
+ */
+export interface LambdaFunction {
+  functionName: string;
+  functionArn: string;
+  runtime?: string;
+  handler?: string;
+  codeSize: number;
+  lastModified: string;
+  memorySize?: number;
+  timeout?: number;
+  description?: string;
+}
+
+/**
+ * AWS Client for interacting with AWS services
+ */
+export class AWSClient {
+  private region: string;
+  private credentials: {
+    accessKeyId: string;
+    secretAccessKey: string;
+  };
+
+  constructor(config?: AWSClientConfig) {
+    this.region = config?.region || process.env.AWS_REGION || 'us-east-1';
+    this.credentials = {
+      accessKeyId: config?.accessKeyId || process.env.AWS_ACCESS_KEY_ID || '',
+      secretAccessKey: config?.secretAccessKey || process.env.AWS_SECRET_ACCESS_KEY || '',
+    };
+
+    if (!this.credentials.accessKeyId || !this.credentials.secretAccessKey) {
+      throw new Error('AWS credentials are required. Set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables.');
+    }
+  }
+
+  /**
+   * Get S3 client instance
+   */
+  private getS3Client(): S3Client {
+    return new S3Client({
+      region: this.region,
+      credentials: this.credentials,
+    });
+  }
+
+  /**
+   * Get EC2 client instance
+   */
+  private getEC2Client(region?: string): EC2Client {
+    return new EC2Client({
+      region: region || this.region,
+      credentials: this.credentials,
+    });
+  }
+
+  /**
+   * Get Lambda client instance
+   */
+  private getLambdaClient(region?: string): LambdaClient {
+    return new LambdaClient({
+      region: region || this.region,
+      credentials: this.credentials,
+    });
+  }
+
+  /**
+   * List all S3 buckets
+   */
+  async listS3Buckets(): Promise<S3Bucket[]> {
+    const client = this.getS3Client();
+    const command = new ListBucketsCommand({});
+
+    try {
+      const response = await client.send(command);
+      return (response.Buckets || []).map(bucket => ({
+        name: bucket.Name || '',
+        creationDate: bucket.CreationDate,
+      }));
+    } catch (error) {
+      throw new Error(`Failed to list S3 buckets: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+
+  /**
+   * List objects in an S3 bucket
+   */
+  async listS3Objects(bucket: string, prefix?: string, maxKeys?: number): Promise<S3Object[]> {
+    const client = this.getS3Client();
+    const command = new ListObjectsV2Command({
+      Bucket: bucket,
+      Prefix: prefix,
+      MaxKeys: maxKeys || 1000,
+    });
+
+    try {
+      const response = await client.send(command);
+      return (response.Contents || []).map(object => ({
+        key: object.Key || '',
+        size: object.Size || 0,
+        lastModified: object.LastModified,
+        etag: object.ETag,
+        storageClass: object.StorageClass,
+      }));
+    } catch (error) {
+      throw new Error(`Failed to list S3 objects in bucket ${bucket}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+
+  /**
+   * Get an object from S3
+   */
+  async getS3Object(bucket: string, key: string): Promise<string> {
+    const client = this.getS3Client();
+    const command = new GetObjectCommand({
+      Bucket: bucket,
+      Key: key,
+    });
+
+    try {
+      const response = await client.send(command);
+      if (!response.Body) {
+        throw new Error('Object body is empty');
+      }
+
+      // Convert stream to string
+      const bodyContents = await response.Body.transformToString();
+      return bodyContents;
+    } catch (error) {
+      throw new Error(`Failed to get S3 object ${key} from bucket ${bucket}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+
+  /**
+   * List EC2 instances
+   */
+  async listEC2Instances(region?: string): Promise<EC2Instance[]> {
+    const client = this.getEC2Client(region);
+    const command = new DescribeInstancesCommand({});
+
+    try {
+      const response = await client.send(command);
+      const instances: EC2Instance[] = [];
+
+      for (const reservation of response.Reservations || []) {
+        for (const instance of reservation.Instances || []) {
+          // Find name tag
+          const nameTag = instance.Tags?.find(tag => tag.Key === 'Name');
+
+          instances.push({
+            instanceId: instance.InstanceId || '',
+            instanceType: instance.InstanceType || '',
+            state: instance.State?.Name || 'unknown',
+            publicIpAddress: instance.PublicIpAddress,
+            privateIpAddress: instance.PrivateIpAddress,
+            launchTime: instance.LaunchTime,
+            name: nameTag?.Value,
+            availabilityZone: instance.Placement?.AvailabilityZone,
+          });
+        }
+      }
+
+      return instances;
+    } catch (error) {
+      throw new Error(`Failed to list EC2 instances: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+
+  /**
+   * List Lambda functions
+   */
+  async listLambdaFunctions(region?: string): Promise<LambdaFunction[]> {
+    const client = this.getLambdaClient(region);
+    const command = new ListFunctionsCommand({});
+
+    try {
+      const response = await client.send(command);
+      return (response.Functions || []).map(func => ({
+        functionName: func.FunctionName || '',
+        functionArn: func.FunctionArn || '',
+        runtime: func.Runtime,
+        handler: func.Handler,
+        codeSize: func.CodeSize || 0,
+        lastModified: func.LastModified || '',
+        memorySize: func.MemorySize,
+        timeout: func.Timeout,
+        description: func.Description,
+      }));
+    } catch (error) {
+      throw new Error(`Failed to list Lambda functions: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+}
+
+/**
+ * Create a singleton AWS client instance
+ */
+let awsClient: AWSClient | null = null;
+
+export function getAWSClient(config?: AWSClientConfig): AWSClient {
+  if (!awsClient) {
+    awsClient = new AWSClient(config);
+  }
+  return awsClient;
+}
+
+export default AWSClient;

package/dist/integrations/bitbucket/connector.json

@@ -0,0 +1,85 @@
+{
+  "name": "bitbucket",
+  "displayName": "Bitbucket",
+  "icon": "bitbucket.svg",
+  "description": "Manage repositories, pull requests, and issues on Bitbucket",
+  "auth": {
+    "type": "oauth2",
+    "provider": "bitbucket",
+    "authorizationUrl": "https://bitbucket.org/site/oauth2/authorize",
+    "tokenUrl": "https://bitbucket.org/site/oauth2/access_token",
+    "scopes": [
+      "repository",
+      "pullrequest",
+      "issue",
+      "account"
+    ],
+    "callbackPath": "/api/auth/bitbucket/callback"
+  },
+  "envVars": [
+    {
+      "name": "BITBUCKET_CLIENT_ID",
+      "description": "Bitbucket OAuth Consumer Key",
+      "required": true,
+      "sensitive": false,
+      "docsUrl": "https://support.atlassian.com/bitbucket-cloud/docs/use-oauth-on-bitbucket-cloud/"
+    },
+    {
+      "name": "BITBUCKET_CLIENT_SECRET",
+      "description": "Bitbucket OAuth Consumer Secret",
+      "required": true,
+      "sensitive": true,
+      "docsUrl": "https://support.atlassian.com/bitbucket-cloud/docs/use-oauth-on-bitbucket-cloud/"
+    }
+  ],
+  "tools": [
+    {
+      "id": "list-repositories",
+      "name": "List Repositories",
+      "description": "Get list of user's repositories",
+      "requiresWrite": false
+    },
+    {
+      "id": "list-pull-requests",
+      "name": "List Pull Requests",
+      "description": "Get pull requests for a repository",
+      "requiresWrite": false
+    },
+    {
+      "id": "create-pull-request",
+      "name": "Create Pull Request",
+      "description": "Create a new pull request",
+      "requiresWrite": true
+    },
+    {
+      "id": "list-issues",
+      "name": "List Issues",
+      "description": "Get issues for a repository",
+      "requiresWrite": false
+    }
+  ],
+  "prompts": [
+    {
+      "id": "review-prs",
+      "title": "Review my pull requests",
+      "prompt": "Show me my open pull requests on Bitbucket and help me review them. Summarize the changes and any comments.",
+      "category": "development",
+      "icon": "git-pull-request"
+    },
+    {
+      "id": "list-repos",
+      "title": "List my repositories",
+      "prompt": "Show me all my Bitbucket repositories with their details and recent activity.",
+      "category": "development",
+      "icon": "folder"
+    },
+    {
+      "id": "check-issues",
+      "title": "Check repository issues",
+      "prompt": "Show me the open issues in my repositories and help me prioritize them.",
+      "category": "development",
+      "icon": "bug"
+    }
+  ],
+  "suggestedWith": ["github", "gitlab", "jira"]
+}

package/dist/integrations/bitbucket/files/_env.example

@@ -0,0 +1,9 @@
+# Bitbucket OAuth Configuration
+# Create a new OAuth consumer at: https://bitbucket.org/account/settings/app-passwords/
+# Or create an OAuth consumer at: https://bitbucket.org/{workspace}/workspace/settings/oauth-consumers/new
+# Set the callback URL to: http://localhost:3000/api/auth/bitbucket/callback
+# (Update the URL for production)
+# Required permissions: repository, pullrequest, issue, account
+
+BITBUCKET_CLIENT_ID=your_bitbucket_client_id
+BITBUCKET_CLIENT_SECRET=your_bitbucket_client_secret

package/dist/integrations/bitbucket/files/ai/tools/create-pull-request.ts

@@ -0,0 +1,83 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { createBitbucketClient } from "../../lib/bitbucket-client.ts";
+
+export default tool({
+  id: "create-pull-request",
+  description: "Create a new pull request in a Bitbucket repository",
+  inputSchema: z.object({
+    workspace: z
+      .string()
+      .describe("Workspace name or UUID"),
+    repoSlug: z
+      .string()
+      .describe("Repository slug (e.g., 'my-repo')"),
+    title: z
+      .string()
+      .min(1)
+      .describe("Pull request title"),
+    description: z
+      .string()
+      .optional()
+      .describe("Pull request description (supports Markdown)"),
+    sourceBranch: z
+      .string()
+      .describe("Source branch name"),
+    destinationBranch: z
+      .string()
+      .describe("Destination branch name"),
+    closeSourceBranch: z
+      .boolean()
+      .optional()
+      .default(false)
+      .describe("Close source branch after merge"),
+  }),
+  execute: async ({
+    workspace,
+    repoSlug,
+    title,
+    description,
+    sourceBranch,
+    destinationBranch,
+    closeSourceBranch,
+  }, context) => {
+    // Default to "current-user" for development; in production, always pass userId from session
+    const userId = (context?.userId as string | undefined) || "current-user";
+
+    try {
+      const bitbucket = createBitbucketClient(userId);
+      const pr = await bitbucket.createPullRequest(workspace, repoSlug, {
+        title,
+        description,
+        sourceBranch,
+        destinationBranch,
+        closeSourceBranch,
+      });
+
+      return {
+        success: true,
+        pullRequest: {
+          id: pr.id,
+          title: pr.title,
+          url: pr.links.html.href,
+          state: pr.state,
+          sourceBranch: pr.source.branch.name,
+          destinationBranch: pr.destination.branch.name,
+          author: {
+            username: pr.author.username,
+            displayName: pr.author.display_name,
+          },
+        },
+        message: `Pull request #${pr.id} created successfully in ${workspace}/${repoSlug}.`,
+      };
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("not connected")) {
+        return {
+          error: "Bitbucket not connected. Please connect your Bitbucket account.",
+          connectUrl: "/api/auth/bitbucket",
+        };
+      }
+      throw error;
+    }
+  },
+});

package/dist/integrations/bitbucket/files/ai/tools/list-issues.ts

@@ -0,0 +1,112 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { createBitbucketClient } from "../../lib/bitbucket-client.ts";
+
+export default tool({
+  id: "list-issues",
+  description: "List issues for a Bitbucket repository",
+  inputSchema: z.object({
+    workspace: z
+      .string()
+      .describe("Workspace name or UUID"),
+    repoSlug: z
+      .string()
+      .describe("Repository slug (e.g., 'my-repo')"),
+    state: z
+      .enum(["new", "open", "resolved", "on hold", "invalid", "duplicate", "wontfix", "closed"])
+      .optional()
+      .describe("Filter by issue state"),
+    kind: z
+      .enum(["bug", "enhancement", "proposal", "task"])
+      .optional()
+      .describe("Filter by issue kind"),
+    priority: z
+      .enum(["trivial", "minor", "major", "critical", "blocker"])
+      .optional()
+      .describe("Filter by priority level"),
+    limit: z
+      .number()
+      .min(1)
+      .max(100)
+      .default(20)
+      .describe("Maximum number of issues to return"),
+  }),
+  execute: async ({ workspace, repoSlug, state, kind, priority, limit }, context) => {
+    // Default to "current-user" for development; in production, always pass userId from session
+    const userId = (context?.userId as string | undefined) || "current-user";
+
+    try {
+      const bitbucket = createBitbucketClient(userId);
+      const issues = await bitbucket.listIssues(workspace, repoSlug, {
+        state,
+        kind,
+        priority,
+        perPage: limit,
+      });
+
+      return {
+        issues: issues.map((
+          issue: {
+            id: number;
+            title: string;
+            state: string;
+            kind: string;
+            priority: string;
+            created_on: string;
+            updated_on: string;
+            reporter: {
+              username: string;
+              display_name: string;
+            };
+            assignee: {
+              username: string;
+              display_name: string;
+            } | null;
+            links: {
+              html: { href: string };
+            };
+            content: {
+              raw: string;
+            } | null;
+          },
+        ) => ({
+          id: issue.id,
+          title: issue.title,
+          state: issue.state,
+          kind: issue.kind,
+          priority: issue.priority,
+          description: issue.content?.raw || null,
+          reporter: {
+            username: issue.reporter.username,
+            displayName: issue.reporter.display_name,
+          },
+          assignee: issue.assignee
+            ? {
+              username: issue.assignee.username,
+              displayName: issue.assignee.display_name,
+            }
+            : null,
+          url: issue.links.html.href,
+          createdOn: issue.created_on,
+          updatedOn: issue.updated_on,
+        })),
+        count: issues.length,
+        repository: `${workspace}/${repoSlug}`,
+        filters: {
+          state: state || "all",
+          kind: kind || "all",
+          priority: priority || "all",
+        },
+        message: `Found ${issues.length} issue(s) in ${workspace}/${repoSlug}.`,
+      };
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("not connected")) {
+        return {
+          error: "Bitbucket not connected. Please connect your Bitbucket account.",
+          connectUrl: "/api/auth/bitbucket",
+        };
+      }
+      throw error;
+    }
+  },
+});

package/dist/integrations/bitbucket/files/ai/tools/list-pull-requests.ts

@@ -0,0 +1,91 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { createBitbucketClient } from "../../lib/bitbucket-client.ts";
+
+export default tool({
+  id: "list-pull-requests",
+  description: "List pull requests for a Bitbucket repository",
+  inputSchema: z.object({
+    workspace: z
+      .string()
+      .describe("Workspace name or UUID"),
+    repoSlug: z
+      .string()
+      .describe("Repository slug (e.g., 'my-repo')"),
+    state: z
+      .enum(["OPEN", "MERGED", "DECLINED", "SUPERSEDED"])
+      .default("OPEN")
+      .describe("State of pull requests to list"),
+    limit: z
+      .number()
+      .min(1)
+      .max(100)
+      .default(10)
+      .describe("Maximum number of pull requests to return"),
+  }),
+  execute: async ({ workspace, repoSlug, state, limit }, context) => {
+    // Default to "current-user" for development; in production, always pass userId from session
+    const userId = (context?.userId as string | undefined) || "current-user";
+
+    try {
+      const bitbucket = createBitbucketClient(userId);
+      const prs = await bitbucket.listPullRequests(workspace, repoSlug, {
+        state,
+        perPage: limit,
+      });
+
+      return {
+        pullRequests: prs.map((
+          pr: {
+            id: number;
+            title: string;
+            state: string;
+            author: {
+              username: string;
+              display_name: string;
+            };
+            created_on: string;
+            updated_on: string;
+            source: {
+              branch: { name: string };
+            };
+            destination: {
+              branch: { name: string };
+            };
+            links: {
+              html: { href: string };
+            };
+            comment_count: number;
+            task_count: number;
+          },
+        ) => ({
+          id: pr.id,
+          title: pr.title,
+          state: pr.state,
+          author: {
+            username: pr.author.username,
+            displayName: pr.author.display_name,
+          },
+          url: pr.links.html.href,
+          sourceBranch: pr.source.branch.name,
+          destinationBranch: pr.destination.branch.name,
+          commentCount: pr.comment_count,
+          taskCount: pr.task_count,
+          createdOn: pr.created_on,
+          updatedOn: pr.updated_on,
+        })),
+        count: prs.length,
+        repository: `${workspace}/${repoSlug}`,
+        message: `Found ${prs.length} ${state} pull request(s) in ${workspace}/${repoSlug}.`,
+      };
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("not connected")) {
+        return {
+          error: "Bitbucket not connected. Please connect your Bitbucket account.",
+          connectUrl: "/api/auth/bitbucket",
+        };
+      }
+      throw error;
+    }
+  },
+});