veryfront 0.0.49 → 0.0.50

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

@@ -0,0 +1,78 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { createBitbucketClient } from "../../lib/bitbucket-client.ts";
+
+export default tool({
+  id: "list-repositories",
+  description: "List Bitbucket repositories for the authenticated user",
+  inputSchema: z.object({
+    role: z
+      .enum(["owner", "contributor", "member"])
+      .optional()
+      .describe("Filter repositories by role"),
+    limit: z
+      .number()
+      .min(1)
+      .max(100)
+      .default(20)
+      .describe("Maximum number of repositories to return"),
+  }),
+  execute: async ({ role, 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 repos = await bitbucket.listRepositories({
+        role,
+        perPage: limit,
+      });
+
+      return {
+        repositories: repos.map((
+          repo: {
+            name: string;
+            full_name: string;
+            description: string | null;
+            is_private: boolean;
+            mainbranch: { name: string } | null;
+            language: string;
+            updated_on: string;
+            created_on: string;
+            links: {
+              html: { href: string };
+            };
+            owner: {
+              username: string;
+              display_name: string;
+            };
+          },
+        ) => ({
+          name: repo.name,
+          fullName: repo.full_name,
+          description: repo.description || null,
+          isPrivate: repo.is_private,
+          mainBranch: repo.mainbranch?.name || null,
+          language: repo.language,
+          url: repo.links.html.href,
+          owner: {
+            username: repo.owner.username,
+            displayName: repo.owner.display_name,
+          },
+          updatedOn: repo.updated_on,
+          createdOn: repo.created_on,
+        })),
+        count: repos.length,
+        message: `Found ${repos.length} repository(s).`,
+      };
+    } 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/app/api/auth/bitbucket/callback/route.ts

@@ -0,0 +1,11 @@
+/**
+ * Bitbucket OAuth Callback
+ */
+
+import { bitbucketConfig, createOAuthCallbackHandler, memoryTokenStore } from "veryfront/oauth";
+
+export const GET = createOAuthCallbackHandler(bitbucketConfig, {
+  tokenStore: memoryTokenStore,
+  onSuccess: () => "/",
+  onError: () => "/",
+});

package/dist/integrations/bitbucket/files/app/api/auth/bitbucket/route.ts

@@ -0,0 +1,9 @@
+/**
+ * Bitbucket OAuth Initiation
+ */
+
+import { bitbucketConfig, createOAuthInitHandler, memoryTokenStore } from "veryfront/oauth";
+
+export const GET = createOAuthInitHandler(bitbucketConfig, {
+  tokenStore: memoryTokenStore,
+});

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

@@ -0,0 +1,316 @@
+/**
+ * Bitbucket API Client
+ *
+ * Provides a type-safe interface to Bitbucket API operations.
+ */
+
+import { tokenStore as _tokenStore } from "./token-store.ts";
+import { getValidToken } from "./oauth.ts";
+
+// Helper for Cross-Platform environment access
+function getEnv(key: string): string | undefined {
+  // @ts-ignore - Deno global
+  if (typeof Deno !== "undefined") {
+    // @ts-ignore - Deno global
+    return Deno.env.get(key);
+  } // @ts-ignore - process global
+  else if (typeof process !== "undefined" && process.env) {
+    // @ts-ignore - process global
+    return process.env[key];
+  }
+  return undefined;
+}
+
+const BITBUCKET_API_BASE = "https://api.bitbucket.org/2.0";
+
+export interface BitbucketUser {
+  uuid: string;
+  username: string;
+  display_name: string;
+  account_id: string;
+  links: {
+    avatar: { href: string };
+    html: { href: string };
+  };
+}
+
+export interface Repository {
+  uuid: string;
+  name: string;
+  full_name: string;
+  description: string | null;
+  is_private: boolean;
+  mainbranch: { name: string } | null;
+  language: string;
+  size: number;
+  updated_on: string;
+  created_on: string;
+  links: {
+    html: { href: string };
+    clone: Array<{ href: string; name: string }>;
+  };
+  owner: {
+    username: string;
+    display_name: string;
+  };
+}
+
+export interface PullRequest {
+  id: number;
+  title: string;
+  description: string;
+  state: "OPEN" | "MERGED" | "DECLINED" | "SUPERSEDED";
+  author: {
+    username: string;
+    display_name: string;
+  };
+  created_on: string;
+  updated_on: string;
+  source: {
+    branch: { name: string };
+    repository: { full_name: string };
+  };
+  destination: {
+    branch: { name: string };
+    repository: { full_name: string };
+  };
+  links: {
+    html: { href: string };
+    diff: { href: string };
+  };
+  comment_count: number;
+  task_count: number;
+}
+
+export interface Issue {
+  id: number;
+  title: string;
+  content: {
+    raw: string;
+  } | null;
+  state: "new" | "open" | "resolved" | "on hold" | "invalid" | "duplicate" | "wontfix" | "closed";
+  kind: "bug" | "enhancement" | "proposal" | "task";
+  priority: "trivial" | "minor" | "major" | "critical" | "blocker";
+  created_on: string;
+  updated_on: string;
+  reporter: {
+    username: string;
+    display_name: string;
+  };
+  assignee: {
+    username: string;
+    display_name: string;
+  } | null;
+  links: {
+    html: { href: string };
+  };
+}
+
+/**
+ * Bitbucket OAuth provider configuration
+ */
+export const bitbucketOAuthProvider = {
+  name: "bitbucket",
+  authorizationUrl: "https://bitbucket.org/site/oauth2/authorize",
+  tokenUrl: "https://bitbucket.org/site/oauth2/access_token",
+  clientId: getEnv("BITBUCKET_CLIENT_ID") || "",
+  clientSecret: getEnv("BITBUCKET_CLIENT_SECRET") || "",
+  scopes: ["repository", "pullrequest", "issue", "account"],
+  callbackPath: "/api/auth/bitbucket/callback",
+};
+
+/**
+ * Create a Bitbucket client for a specific user
+ */
+export function createBitbucketClient(userId: string) {
+  async function getAccessToken(): Promise<string> {
+    const token = await getValidToken(bitbucketOAuthProvider, userId, "bitbucket");
+    if (!token) {
+      throw new Error("Bitbucket not connected. Please connect your Bitbucket account first.");
+    }
+    return token;
+  }
+
+  async function apiRequest<T>(
+    endpoint: string,
+    options: RequestInit = {},
+  ): Promise<T> {
+    const accessToken = await getAccessToken();
+
+    const response = await fetch(`${BITBUCKET_API_BASE}${endpoint}`, {
+      ...options,
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        ...options.headers,
+      },
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Bitbucket API error: ${response.status} - ${error}`);
+    }
+
+    return response.json();
+  }
+
+  return {
+    /**
+     * Get authenticated user
+     */
+    getCurrentUser(): Promise<BitbucketUser> {
+      return apiRequest("/user");
+    },
+
+    /**
+     * List user's repositories
+     */
+    async listRepositories(options: {
+      role?: "owner" | "contributor" | "member";
+      perPage?: number;
+    } = {}): Promise<Repository[]> {
+      const params = new URLSearchParams();
+      if (options.role) params.set("role", options.role);
+      if (options.perPage) params.set("pagelen", String(options.perPage));
+
+      const query = params.toString();
+      const response = await apiRequest<{ values: Repository[] }>(
+        `/repositories?${query ? query : ""}`,
+      );
+      return response.values;
+    },
+
+    /**
+     * Get repository details
+     */
+    getRepository(workspace: string, repoSlug: string): Promise<Repository> {
+      return apiRequest(`/repositories/${workspace}/${repoSlug}`);
+    },
+
+    /**
+     * List pull requests for a repository
+     */
+    async listPullRequests(
+      workspace: string,
+      repoSlug: string,
+      options: {
+        state?: "OPEN" | "MERGED" | "DECLINED" | "SUPERSEDED";
+        perPage?: number;
+      } = {},
+    ): Promise<PullRequest[]> {
+      const params = new URLSearchParams();
+      if (options.state) params.set("state", options.state);
+      if (options.perPage) params.set("pagelen", String(options.perPage));
+
+      const query = params.toString();
+      const response = await apiRequest<{ values: PullRequest[] }>(
+        `/repositories/${workspace}/${repoSlug}/pullrequests${query ? `?${query}` : ""}`,
+      );
+      return response.values;
+    },
+
+    /**
+     * Get a single pull request
+     */
+    getPullRequest(
+      workspace: string,
+      repoSlug: string,
+      pullRequestId: number,
+    ): Promise<PullRequest> {
+      return apiRequest(
+        `/repositories/${workspace}/${repoSlug}/pullrequests/${pullRequestId}`,
+      );
+    },
+
+    /**
+     * Create a pull request
+     */
+    createPullRequest(
+      workspace: string,
+      repoSlug: string,
+      options: {
+        title: string;
+        description?: string;
+        sourceBranch: string;
+        destinationBranch: string;
+        closeSourceBranch?: boolean;
+      },
+    ): Promise<PullRequest> {
+      return apiRequest(`/repositories/${workspace}/${repoSlug}/pullrequests`, {
+        method: "POST",
+        body: JSON.stringify({
+          title: options.title,
+          description: options.description,
+          source: {
+            branch: { name: options.sourceBranch },
+          },
+          destination: {
+            branch: { name: options.destinationBranch },
+          },
+          close_source_branch: options.closeSourceBranch,
+        }),
+      });
+    },
+
+    /**
+     * List issues for a repository
+     */
+    async listIssues(
+      workspace: string,
+      repoSlug: string,
+      options: {
+        state?:
+          | "new"
+          | "open"
+          | "resolved"
+          | "on hold"
+          | "invalid"
+          | "duplicate"
+          | "wontfix"
+          | "closed";
+        kind?: "bug" | "enhancement" | "proposal" | "task";
+        priority?: "trivial" | "minor" | "major" | "critical" | "blocker";
+        perPage?: number;
+      } = {},
+    ): Promise<Issue[]> {
+      const params = new URLSearchParams();
+      if (options.state) params.set("q", `state="${options.state}"`);
+      if (options.kind) params.set("kind", options.kind);
+      if (options.priority) params.set("priority", options.priority);
+      if (options.perPage) params.set("pagelen", String(options.perPage));
+
+      const query = params.toString();
+      const response = await apiRequest<{ values: Issue[] }>(
+        `/repositories/${workspace}/${repoSlug}/issues${query ? `?${query}` : ""}`,
+      );
+      return response.values;
+    },
+
+    /**
+     * Create an issue
+     */
+    createIssue(
+      workspace: string,
+      repoSlug: string,
+      options: {
+        title: string;
+        description?: string;
+        kind?: "bug" | "enhancement" | "proposal" | "task";
+        priority?: "trivial" | "minor" | "major" | "critical" | "blocker";
+      },
+    ): Promise<Issue> {
+      return apiRequest(`/repositories/${workspace}/${repoSlug}/issues`, {
+        method: "POST",
+        body: JSON.stringify({
+          title: options.title,
+          content: options.description ? { raw: options.description } : undefined,
+          kind: options.kind || "bug",
+          priority: options.priority || "major",
+        }),
+      });
+    },
+  };
+}
+
+export type BitbucketClient = ReturnType<typeof createBitbucketClient>;

package/dist/integrations/bitbucket/files/lib/token-store.ts

@@ -0,0 +1,5 @@
+/**
+ * Bitbucket Token Store
+ */
+
+export { memoryTokenStore as tokenStore, type OAuthTokens, type TokenStore } from "veryfront/oauth";

package/dist/integrations/box/connector.json

@@ -0,0 +1,85 @@
+{
+  "name": "box",
+  "displayName": "Box",
+  "icon": "box.svg",
+  "description": "Access and manage files, folders, and content in Box",
+  "auth": {
+    "type": "oauth2",
+    "provider": "box",
+    "authorizationUrl": "https://account.box.com/api/oauth2/authorize",
+    "tokenUrl": "https://api.box.com/oauth2/token",
+    "scopes": ["root_readwrite"],
+    "callbackPath": "/api/auth/box/callback",
+    "requiredApis": [
+      {
+        "name": "Box Developer Console",
+        "enableUrl": "https://app.box.com/developers/console"
+      }
+    ]
+  },
+  "envVars": [
+    {
+      "name": "BOX_CLIENT_ID",
+      "description": "Box OAuth Client ID",
+      "required": true,
+      "sensitive": false,
+      "docsUrl": "https://developer.box.com/guides/authentication/oauth2/"
+    },
+    {
+      "name": "BOX_CLIENT_SECRET",
+      "description": "Box OAuth Client Secret",
+      "required": true,
+      "sensitive": true,
+      "docsUrl": "https://developer.box.com/guides/authentication/oauth2/"
+    }
+  ],
+  "tools": [
+    {
+      "id": "list-files",
+      "name": "List Files",
+      "description": "List files and folders in a Box folder",
+      "requiresWrite": false
+    },
+    {
+      "id": "get-file",
+      "name": "Get File",
+      "description": "Get details of a specific file or folder",
+      "requiresWrite": false
+    },
+    {
+      "id": "search-files",
+      "name": "Search Files",
+      "description": "Search for files and folders in Box",
+      "requiresWrite": false
+    },
+    {
+      "id": "create-folder",
+      "name": "Create Folder",
+      "description": "Create a new folder in Box",
+      "requiresWrite": true
+    },
+    {
+      "id": "upload-file",
+      "name": "Upload File",
+      "description": "Upload a file to Box",
+      "requiresWrite": true
+    }
+  ],
+  "prompts": [
+    {
+      "id": "my-files",
+      "title": "Show my files",
+      "prompt": "List all files in my Box root folder with their details.",
+      "category": "productivity",
+      "icon": "folder"
+    },
+    {
+      "id": "search-content",
+      "title": "Search for files",
+      "prompt": "Search for files in Box by name or content.",
+      "category": "productivity",
+      "icon": "search"
+    }
+  ],
+  "suggestedWith": ["dropbox", "onedrive", "notion"]
+}

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

@@ -0,0 +1,4 @@
+# Box OAuth Configuration
+# Get your credentials from https://app.box.com/developers/console
+BOX_CLIENT_ID=your-client-id
+BOX_CLIENT_SECRET=your-client-secret

package/dist/integrations/box/files/ai/tools/create-folder.ts

@@ -0,0 +1,28 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { createFolder } from "../../lib/box-client.ts";
+
+export default tool({
+  id: "create-folder",
+  description: "Create a new folder in Box. Use '0' as parent folder ID to create in the root folder.",
+  inputSchema: z.object({
+    parentFolderId: z.string().describe("The ID of the parent folder (use '0' for root folder)"),
+    name: z.string().describe("The name of the folder to create"),
+  }),
+  async execute({ parentFolderId, name }) {
+    const folder = await createFolder({
+      parentFolderId,
+      name,
+    });
+
+    return {
+      success: true,
+      folder: {
+        id: folder.id,
+        name: folder.name,
+        createdAt: folder.created_at,
+        path: folder.path_collection?.entries.map((e) => e.name).join("/") || "/",
+      },
+    };
+  },
+});

package/dist/integrations/box/files/ai/tools/get-file.ts

@@ -0,0 +1,29 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getFile } from "../../lib/box-client.ts";
+
+export default tool({
+  id: "get-file",
+  description: "Get detailed information about a specific file or folder in Box.",
+  inputSchema: z.object({
+    itemId: z.string().describe("The ID of the file or folder"),
+    itemType: z.enum(["file", "folder"]).default("file").describe("Whether the item is a file or folder"),
+  }),
+  async execute({ itemId, itemType }) {
+    const item = await getFile(itemId, itemType);
+
+    return {
+      id: item.id,
+      type: item.type,
+      name: item.name,
+      size: item.type === "file" ? item.size : undefined,
+      description: item.description,
+      createdAt: item.created_at,
+      modifiedAt: item.modified_at,
+      createdBy: item.created_by?.name,
+      modifiedBy: item.modified_by?.name,
+      path: item.path_collection?.entries.map((e) => e.name).join("/") || "/",
+      sharedLink: item.type === "file" ? item.shared_link?.url : undefined,
+    };
+  },
+});

package/dist/integrations/box/files/ai/tools/list-files.ts

@@ -0,0 +1,33 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listFiles } from "../../lib/box-client.ts";
+
+export default tool({
+  id: "list-files",
+  description:
+    "List files and folders from a Box folder. Use folder ID '0' for the root folder.",
+  inputSchema: z.object({
+    folderId: z.string().default("0").describe("Folder ID to list files from (use '0' for root folder)"),
+    limit: z.number().min(1).max(100).default(50).describe("Maximum number of items to return"),
+    offset: z.number().min(0).default(0).describe("Number of items to skip for pagination"),
+  }),
+  async execute({ folderId, limit, offset }) {
+    const items = await listFiles({
+      folderId,
+      limit,
+      offset,
+    });
+
+    return items.map((item) => ({
+      id: item.id,
+      type: item.type,
+      name: item.name,
+      size: item.type === "file" ? item.size : undefined,
+      createdAt: item.created_at,
+      modifiedAt: item.modified_at,
+      createdBy: item.created_by?.name,
+      modifiedBy: item.modified_by?.name,
+      path: item.path_collection?.entries.map((e) => e.name).join("/") || "/",
+    }));
+  },
+});

package/dist/integrations/box/files/ai/tools/search-files.ts

@@ -0,0 +1,35 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { searchFiles } from "../../lib/box-client.ts";
+
+export default tool({
+  id: "search-files",
+  description:
+    "Search for files and folders in Box by name or content. Returns matching items with their details.",
+  inputSchema: z.object({
+    query: z.string().describe("Search query string to find files and folders"),
+    limit: z.number().min(1).max(100).default(50).describe("Maximum number of results to return"),
+    offset: z.number().min(0).default(0).describe("Number of results to skip for pagination"),
+    contentTypes: z.array(z.string()).optional().describe(
+      "Filter by content types (e.g., ['name', 'description', 'file_content'])",
+    ),
+  }),
+  async execute({ query, limit, offset, contentTypes }) {
+    const results = await searchFiles({
+      query,
+      limit,
+      offset,
+      contentTypes,
+    });
+
+    return results.map((item) => ({
+      id: item.id,
+      type: item.type,
+      name: item.name,
+      size: item.size,
+      createdAt: item.created_at,
+      modifiedAt: item.modified_at,
+      path: item.path_collection?.entries.map((e) => e.name).join("/") || "/",
+    }));
+  },
+});

package/dist/integrations/box/files/ai/tools/upload-file.ts

@@ -0,0 +1,32 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { uploadFile } from "../../lib/box-client.ts";
+
+export default tool({
+  id: "upload-file",
+  description:
+    "Upload a file to Box. Provide the file content as a string. Use '0' as parent folder ID to upload to the root folder.",
+  inputSchema: z.object({
+    parentFolderId: z.string().describe("The ID of the parent folder to upload to (use '0' for root folder)"),
+    fileName: z.string().describe("The name of the file including extension (e.g., 'document.txt')"),
+    fileContent: z.string().describe("The content of the file as a string"),
+  }),
+  async execute({ parentFolderId, fileName, fileContent }) {
+    const file = await uploadFile({
+      parentFolderId,
+      fileName,
+      fileContent,
+    });
+
+    return {
+      success: true,
+      file: {
+        id: file.id,
+        name: file.name,
+        size: file.size,
+        createdAt: file.created_at,
+        path: file.path_collection?.entries.map((e) => e.name).join("/") || "/",
+      },
+    };
+  },
+});

package/dist/integrations/box/files/app/api/auth/box/callback/route.ts

@@ -0,0 +1,11 @@
+/**
+ * Box OAuth Callback
+ */
+
+import { boxConfig, createOAuthCallbackHandler, memoryTokenStore } from "veryfront/oauth";
+
+export const GET = createOAuthCallbackHandler(boxConfig, {
+  tokenStore: memoryTokenStore,
+  onSuccess: () => "/",
+  onError: () => "/",
+});