veryfront 0.0.45 → 0.0.46

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

@@ -0,0 +1,282 @@
+/**
+ * GitHub API Client
+ *
+ * Provides a type-safe interface to GitHub 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 GITHUB_API_BASE = "https://api.github.com";
+
+export interface GitHubRepo {
+  id: number;
+  name: string;
+  full_name: string;
+  description: string | null;
+  private: boolean;
+  html_url: string;
+  default_branch: string;
+  language: string | null;
+  stargazers_count: number;
+  forks_count: number;
+  open_issues_count: number;
+  updated_at: string;
+}
+
+export interface GitHubPullRequest {
+  id: number;
+  number: number;
+  title: string;
+  body: string | null;
+  state: "open" | "closed";
+  html_url: string;
+  user: { login: string; avatar_url: string };
+  created_at: string;
+  updated_at: string;
+  head: { ref: string; sha: string };
+  base: { ref: string };
+  mergeable: boolean | null;
+  additions: number;
+  deletions: number;
+  changed_files: number;
+  draft: boolean;
+  labels: Array<{ name: string; color: string }>;
+}
+
+export interface GitHubIssue {
+  id: number;
+  number: number;
+  title: string;
+  body: string | null;
+  state: "open" | "closed";
+  html_url: string;
+  user: { login: string };
+  created_at: string;
+  updated_at: string;
+  labels: Array<{ name: string; color: string }>;
+  assignees: Array<{ login: string }>;
+}
+
+export interface GitHubCommit {
+  sha: string;
+  commit: {
+    message: string;
+    author: { name: string; date: string };
+  };
+  html_url: string;
+  author: { login: string; avatar_url: string } | null;
+}
+
+/**
+ * GitHub OAuth provider configuration
+ */
+export const githubOAuthProvider = {
+  name: "github",
+  authorizationUrl: "https://github.com/login/oauth/authorize",
+  tokenUrl: "https://github.com/login/oauth/access_token",
+  clientId: getEnv("GITHUB_CLIENT_ID") || "",
+  clientSecret: getEnv("GITHUB_CLIENT_SECRET") || "",
+  scopes: ["repo", "read:user", "read:org"],
+  callbackPath: "/api/auth/github/callback",
+};
+
+/**
+ * Create a GitHub client for a specific user
+ */
+export function createGitHubClient(userId: string) {
+  async function getAccessToken(): Promise<string> {
+    const token = await getValidToken(githubOAuthProvider, userId, "github");
+    if (!token) {
+      throw new Error("GitHub not connected. Please connect your GitHub account first.");
+    }
+    return token;
+  }
+
+  async function apiRequest<T>(
+    endpoint: string,
+    options: RequestInit = {},
+  ): Promise<T> {
+    const accessToken = await getAccessToken();
+
+    const response = await fetch(`${GITHUB_API_BASE}${endpoint}`, {
+      ...options,
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        Accept: "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+        ...options.headers,
+      },
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`GitHub API error: ${response.status} - ${error}`);
+    }
+
+    return response.json();
+  }
+
+  return {
+    /**
+     * List user's repositories
+     */
+    listRepos(options: {
+      sort?: "created" | "updated" | "pushed" | "full_name";
+      perPage?: number;
+      type?: "all" | "owner" | "public" | "private" | "member";
+    } = {}): Promise<GitHubRepo[]> {
+      const params = new URLSearchParams();
+      if (options.sort) params.set("sort", options.sort);
+      if (options.perPage) params.set("per_page", String(options.perPage));
+      if (options.type) params.set("type", options.type);
+
+      const query = params.toString();
+      return apiRequest<GitHubRepo[]>(`/user/repos${query ? `?${query}` : ""}`);
+    },
+
+    /**
+     * List pull requests for a repository
+     */
+    listPullRequests(
+      owner: string,
+      repo: string,
+      options: {
+        state?: "open" | "closed" | "all";
+        perPage?: number;
+      } = {},
+    ): Promise<GitHubPullRequest[]> {
+      const params = new URLSearchParams();
+      params.set("state", options.state || "open");
+      if (options.perPage) params.set("per_page", String(options.perPage));
+
+      return apiRequest<GitHubPullRequest[]>(
+        `/repos/${owner}/${repo}/pulls?${params.toString()}`,
+      );
+    },
+
+    /**
+     * Get a single pull request
+     */
+    getPullRequest(
+      owner: string,
+      repo: string,
+      pullNumber: number,
+    ): Promise<GitHubPullRequest> {
+      return apiRequest<GitHubPullRequest>(
+        `/repos/${owner}/${repo}/pulls/${pullNumber}`,
+      );
+    },
+
+    /**
+     * Get pull request diff
+     */
+    async getPullRequestDiff(
+      owner: string,
+      repo: string,
+      pullNumber: number,
+    ): Promise<string> {
+      const accessToken = await getAccessToken();
+
+      const response = await fetch(
+        `${GITHUB_API_BASE}/repos/${owner}/${repo}/pulls/${pullNumber}`,
+        {
+          headers: {
+            Authorization: `Bearer ${accessToken}`,
+            Accept: "application/vnd.github.diff",
+            "X-GitHub-Api-Version": "2022-11-28",
+          },
+        },
+      );
+
+      if (!response.ok) {
+        throw new Error(`GitHub API error: ${response.status}`);
+      }
+
+      return response.text();
+    },
+
+    /**
+     * Create an issue
+     */
+    createIssue(
+      owner: string,
+      repo: string,
+      options: {
+        title: string;
+        body?: string;
+        labels?: string[];
+        assignees?: string[];
+      },
+    ): Promise<GitHubIssue> {
+      return apiRequest<GitHubIssue>(`/repos/${owner}/${repo}/issues`, {
+        method: "POST",
+        body: JSON.stringify(options),
+      });
+    },
+
+    /**
+     * List issues for a repository
+     */
+    listIssues(
+      owner: string,
+      repo: string,
+      options: {
+        state?: "open" | "closed" | "all";
+        perPage?: number;
+      } = {},
+    ): Promise<GitHubIssue[]> {
+      const params = new URLSearchParams();
+      params.set("state", options.state || "open");
+      if (options.perPage) params.set("per_page", String(options.perPage));
+
+      return apiRequest<GitHubIssue[]>(
+        `/repos/${owner}/${repo}/issues?${params.toString()}`,
+      );
+    },
+
+    /**
+     * List commits for a repository
+     */
+    listCommits(
+      owner: string,
+      repo: string,
+      options: {
+        sha?: string;
+        perPage?: number;
+      } = {},
+    ): Promise<GitHubCommit[]> {
+      const params = new URLSearchParams();
+      if (options.sha) params.set("sha", options.sha);
+      if (options.perPage) params.set("per_page", String(options.perPage));
+
+      const query = params.toString();
+      return apiRequest<GitHubCommit[]>(
+        `/repos/${owner}/${repo}/commits${query ? `?${query}` : ""}`,
+      );
+    },
+
+    /**
+     * Get authenticated user
+     */
+    getUser(): Promise<{ login: string; name: string; email: string }> {
+      return apiRequest("/user");
+    },
+  };
+}
+
+export type GitHubClient = ReturnType<typeof createGitHubClient>;

package/dist/integrations/github/files/lib/oauth.ts

@@ -0,0 +1,145 @@
+/**
+ * OAuth Helper Functions
+ *
+ * Provides utilities for OAuth 2.0 authorization flows.
+ */
+
+import { type OAuthToken, tokenStore } from "./token-store.ts";
+
+export interface OAuthProvider {
+  name: string;
+  authorizationUrl: string;
+  tokenUrl: string;
+  clientId: string;
+  clientSecret: string;
+  scopes: string[];
+  callbackPath: string;
+}
+
+/**
+ * Generate OAuth authorization URL
+ */
+export function getAuthorizationUrl(
+  provider: OAuthProvider,
+  state: string,
+  redirectUri: string,
+): string {
+  const params = new URLSearchParams({
+    client_id: provider.clientId,
+    redirect_uri: redirectUri,
+    response_type: "code",
+    scope: provider.scopes.join(" "),
+    state,
+    access_type: "offline",
+    prompt: "consent",
+  });
+
+  return `${provider.authorizationUrl}?${params.toString()}`;
+}
+
+/**
+ * Exchange authorization code for tokens
+ */
+export async function exchangeCodeForTokens(
+  provider: OAuthProvider,
+  code: string,
+  redirectUri: string,
+): Promise<OAuthToken> {
+  const response = await fetch(provider.tokenUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+    },
+    body: new URLSearchParams({
+      client_id: provider.clientId,
+      client_secret: provider.clientSecret,
+      code,
+      grant_type: "authorization_code",
+      redirect_uri: redirectUri,
+    }),
+  });
+
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Token exchange failed: ${response.status} - ${error}`);
+  }
+
+  const data = await response.json();
+
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token,
+    expiresAt: data.expires_in ? Date.now() + (data.expires_in * 1000) : undefined,
+    tokenType: data.token_type || "Bearer",
+    scope: data.scope,
+  };
+}
+
+/**
+ * Refresh an expired access token
+ */
+export async function refreshAccessToken(
+  provider: OAuthProvider,
+  refreshToken: string,
+): Promise<OAuthToken> {
+  const response = await fetch(provider.tokenUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+    },
+    body: new URLSearchParams({
+      client_id: provider.clientId,
+      client_secret: provider.clientSecret,
+      refresh_token: refreshToken,
+      grant_type: "refresh_token",
+    }),
+  });
+
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Token refresh failed: ${response.status} - ${error}`);
+  }
+
+  const data = await response.json();
+
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token || refreshToken,
+    expiresAt: data.expires_in ? Date.now() + (data.expires_in * 1000) : undefined,
+    tokenType: data.token_type || "Bearer",
+    scope: data.scope,
+  };
+}
+
+/**
+ * Get a valid access token, refreshing if necessary
+ */
+export async function getValidToken(
+  provider: OAuthProvider,
+  userId: string,
+  service: string,
+): Promise<string | null> {
+  const token = await tokenStore.getToken(userId, service);
+
+  if (!token) {
+    return null;
+  }
+
+  // Check if token is expired (with 5 minute buffer)
+  // If no expiresAt, token doesn't expire (e.g., GitHub)
+  const isExpired = token.expiresAt ? token.expiresAt < Date.now() + 5 * 60 * 1000 : false;
+
+  if (isExpired && token.refreshToken) {
+    try {
+      const newToken = await refreshAccessToken(provider, token.refreshToken);
+      await tokenStore.setToken(userId, service, newToken);
+      return newToken.accessToken;
+    } catch {
+      // Refresh failed, user needs to re-authorize
+      await tokenStore.revokeToken(userId, service);
+      return null;
+    }
+  }
+
+  return token.accessToken;
+}

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

@@ -0,0 +1,109 @@
+/**
+ * OAuth Token Store
+ *
+ * Simple in-memory token store for development.
+ * Replace with a database or KV store for production.
+ */
+
+export interface OAuthToken {
+  accessToken: string;
+  refreshToken?: string;
+  expiresAt?: number;
+  tokenType?: string;
+  scope?: string;
+}
+
+export interface TokenStore {
+  getToken(userId: string, service: string): Promise<OAuthToken | null>;
+  setToken(userId: string, service: string, token: OAuthToken): Promise<void>;
+  revokeToken(userId: string, service: string): Promise<void>;
+  isConnected(userId: string, service: string): Promise<boolean>;
+}
+
+// In-memory storage for development
+const tokens = new Map<string, OAuthToken>();
+
+function getKey(userId: string, service: string): string {
+  return `${userId}:${service}`;
+}
+
+/**
+ * Simple in-memory token store
+ *
+ * NOTE: This is for development only. In production, use:
+ * - Database (Postgres, SQLite, etc.)
+ * - KV store (Cloudflare Workers KV, Vercel KV, etc.)
+ * - Encrypted file storage
+ */
+export const tokenStore: TokenStore = {
+  getToken(userId: string, service: string): Promise<OAuthToken | null> {
+    const key = getKey(userId, service);
+    return Promise.resolve(tokens.get(key) || null);
+  },
+
+  setToken(
+    userId: string,
+    service: string,
+    token: OAuthToken,
+  ): Promise<void> {
+    const key = getKey(userId, service);
+    tokens.set(key, token);
+    return Promise.resolve();
+  },
+
+  revokeToken(userId: string, service: string): Promise<void> {
+    const key = getKey(userId, service);
+    tokens.delete(key);
+    return Promise.resolve();
+  },
+
+  async isConnected(userId: string, service: string): Promise<boolean> {
+    const token = await this.getToken(userId, service);
+    if (!token) return false;
+    // Check if token is not expired (if no expiry, token doesn't expire)
+    return !token.expiresAt || token.expiresAt > Date.now();
+  },
+};
+
+/**
+ * Factory function to create a custom token store
+ */
+export function createTokenStore(options: {
+  get: (key: string) => Promise<string | null>;
+  set: (key: string, value: string) => Promise<void>;
+  delete: (key: string) => Promise<void>;
+}): TokenStore {
+  return {
+    async getToken(userId: string, service: string): Promise<OAuthToken | null> {
+      const key = getKey(userId, service);
+      const data = await options.get(key);
+      if (!data) return null;
+      try {
+        return JSON.parse(data) as OAuthToken;
+      } catch {
+        return null;
+      }
+    },
+
+    async setToken(
+      userId: string,
+      service: string,
+      token: OAuthToken,
+    ): Promise<void> {
+      const key = getKey(userId, service);
+      await options.set(key, JSON.stringify(token));
+    },
+
+    async revokeToken(userId: string, service: string): Promise<void> {
+      const key = getKey(userId, service);
+      await options.delete(key);
+    },
+
+    async isConnected(userId: string, service: string): Promise<boolean> {
+      const token = await this.getToken(userId, service);
+      if (!token) return false;
+      // Check if token is not expired (if no expiry, token doesn't expire)
+      return !token.expiresAt || token.expiresAt > Date.now();
+    },
+  };
+}

package/dist/integrations/gmail/connector.json

@@ -0,0 +1,78 @@
+{
+  "name": "gmail",
+  "displayName": "Gmail",
+  "icon": "gmail.svg",
+  "description": "Read and send emails via Gmail API",
+  "auth": {
+    "type": "oauth2",
+    "provider": "google",
+    "authorizationUrl": "https://accounts.google.com/o/oauth2/v2/auth",
+    "tokenUrl": "https://oauth2.googleapis.com/token",
+    "scopes": [
+      "https://www.googleapis.com/auth/gmail.readonly",
+      "https://www.googleapis.com/auth/gmail.send",
+      "https://www.googleapis.com/auth/gmail.modify"
+    ],
+    "callbackPath": "/api/auth/gmail/callback"
+  },
+  "envVars": [
+    {
+      "name": "GOOGLE_CLIENT_ID",
+      "description": "Google OAuth Client ID",
+      "required": true,
+      "sensitive": false,
+      "docsUrl": "https://console.cloud.google.com/apis/credentials"
+    },
+    {
+      "name": "GOOGLE_CLIENT_SECRET",
+      "description": "Google OAuth Client Secret",
+      "required": true,
+      "sensitive": true,
+      "docsUrl": "https://console.cloud.google.com/apis/credentials"
+    }
+  ],
+  "tools": [
+    {
+      "id": "list-emails",
+      "name": "List Emails",
+      "description": "Get recent emails from inbox",
+      "requiresWrite": false
+    },
+    {
+      "id": "send-email",
+      "name": "Send Email",
+      "description": "Send an email to recipients",
+      "requiresWrite": true
+    },
+    {
+      "id": "search-emails",
+      "name": "Search Emails",
+      "description": "Search emails by query",
+      "requiresWrite": false
+    }
+  ],
+  "prompts": [
+    {
+      "id": "summarize-emails",
+      "title": "Summarize today's emails",
+      "prompt": "Summarize my unread emails from today. Group them by priority and highlight any that need immediate attention.",
+      "category": "productivity",
+      "icon": "mail"
+    },
+    {
+      "id": "draft-reply",
+      "title": "Draft a quick reply",
+      "prompt": "Help me draft a reply to my most recent email. Keep it professional and concise.",
+      "category": "productivity",
+      "icon": "reply"
+    },
+    {
+      "id": "find-emails",
+      "title": "Find important emails",
+      "prompt": "Search my emails for important messages from the past week that I might have missed.",
+      "category": "productivity",
+      "icon": "search"
+    }
+  ],
+  "suggestedWith": ["calendar", "slack"]
+}

package/dist/integrations/gmail/files/ai/tools/list-emails.ts

@@ -0,0 +1,92 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { createGmailClient, parseEmailHeaders } from "../../lib/gmail-client.ts";
+
+export default tool({
+  id: "list-emails",
+  description:
+    "List recent emails from Gmail inbox. Returns email subjects, senders, and snippets.",
+  inputSchema: z.object({
+    maxResults: z
+      .number()
+      .min(1)
+      .max(50)
+      .default(10)
+      .describe("Maximum number of emails to return"),
+    unreadOnly: z
+      .boolean()
+      .default(false)
+      .describe("Only return unread emails"),
+    label: z
+      .string()
+      .optional()
+      .describe("Filter by Gmail label (e.g., 'INBOX', 'IMPORTANT', 'STARRED')"),
+  }),
+  execute: async ({ maxResults, unreadOnly, label }, context) => {
+    const userId = context?.userId as string | undefined;
+    if (!userId) {
+      return {
+        error: "User not authenticated. Please log in first.",
+      };
+    }
+
+    try {
+      const gmail = createGmailClient(userId);
+
+      let query = "";
+      if (unreadOnly) {
+        query = "is:unread";
+      }
+
+      const labelIds = label ? [label] : undefined;
+
+      const list = await gmail.listMessages({
+        maxResults,
+        query: query || undefined,
+        labelIds,
+      });
+
+      if (!list.messages || list.messages.length === 0) {
+        return {
+          emails: [],
+          message: "No emails found matching your criteria.",
+        };
+      }
+
+      // Fetch metadata for each email
+      const emails = await Promise.all(
+        list.messages.map(async (m: { id: string }) => {
+          const message = await gmail.getMessage(m.id, "metadata");
+          const headers = parseEmailHeaders(message.payload?.headers || []);
+
+          return {
+            id: message.id,
+            threadId: message.threadId,
+            from: headers.from,
+            to: headers.to,
+            subject: headers.subject,
+            date: headers.date,
+            snippet: message.snippet,
+            isUnread: message.labelIds?.includes("UNREAD") || false,
+            isStarred: message.labelIds?.includes("STARRED") || false,
+            isImportant: message.labelIds?.includes("IMPORTANT") || false,
+          };
+        }),
+      );
+
+      return {
+        emails,
+        count: emails.length,
+        message: `Found ${emails.length} email(s).`,
+      };
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("not connected")) {
+        return {
+          error: "Gmail not connected. Please connect your Gmail account.",
+          connectUrl: "/api/auth/gmail",
+        };
+      }
+      throw error;
+    }
+  },
+});