veryfront 0.0.44 → 0.0.46

package/dist/integrations/slack/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/slack/files/lib/slack-client.ts

@@ -0,0 +1,215 @@
+/**
+ * Slack API Client
+ *
+ * Provides a type-safe interface to Slack 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 SLACK_API_BASE = "https://slack.com/api";
+
+export interface SlackChannel {
+  id: string;
+  name: string;
+  is_channel: boolean;
+  is_private: boolean;
+  is_member: boolean;
+  topic?: { value: string };
+  purpose?: { value: string };
+}
+
+export interface SlackMessage {
+  type: string;
+  user?: string;
+  text: string;
+  ts: string;
+  thread_ts?: string;
+  reply_count?: number;
+  reactions?: Array<{ name: string; count: number }>;
+}
+
+export interface SlackUser {
+  id: string;
+  name: string;
+  real_name: string;
+  profile: {
+    display_name: string;
+    email?: string;
+    image_48?: string;
+  };
+}
+
+/**
+ * Slack OAuth provider configuration
+ */
+export const slackOAuthProvider = {
+  name: "slack",
+  authorizationUrl: "https://slack.com/oauth/v2/authorize",
+  tokenUrl: "https://slack.com/api/oauth.v2.access",
+  clientId: getEnv("SLACK_CLIENT_ID") || "",
+  clientSecret: getEnv("SLACK_CLIENT_SECRET") || "",
+  scopes: [
+    "channels:history",
+    "channels:read",
+    "chat:write",
+    "users:read",
+    "im:history",
+    "im:read",
+  ],
+  callbackPath: "/api/auth/slack/callback",
+};
+
+/**
+ * Create a Slack client for a specific user
+ */
+export function createSlackClient(userId: string) {
+  async function getAccessToken(): Promise<string> {
+    const token = await getValidToken(slackOAuthProvider, userId, "slack");
+    if (!token) {
+      throw new Error("Slack not connected. Please connect your Slack account first.");
+    }
+    return token;
+  }
+
+  async function apiRequest<T>(
+    method: string,
+    params: Record<string, unknown> = {},
+  ): Promise<T> {
+    const accessToken = await getAccessToken();
+
+    const response = await fetch(`${SLACK_API_BASE}/${method}`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json; charset=utf-8",
+      },
+      body: JSON.stringify(params),
+    });
+
+    const data = await response.json();
+
+    if (!data.ok) {
+      throw new Error(`Slack API error: ${data.error}`);
+    }
+
+    return data as T;
+  }
+
+  return {
+    /**
+     * List channels the user is a member of
+     */
+    async listChannels(options: {
+      limit?: number;
+      excludeArchived?: boolean;
+    } = {}): Promise<SlackChannel[]> {
+      const result = await apiRequest<{ channels: SlackChannel[] }>(
+        "conversations.list",
+        {
+          limit: options.limit || 100,
+          exclude_archived: options.excludeArchived ?? true,
+          types: "public_channel,private_channel",
+        },
+      );
+      return result.channels;
+    },
+
+    /**
+     * Get messages from a channel
+     */
+    async getMessages(
+      channelId: string,
+      options: { limit?: number; oldest?: string } = {},
+    ): Promise<SlackMessage[]> {
+      const result = await apiRequest<{ messages: SlackMessage[] }>(
+        "conversations.history",
+        {
+          channel: channelId,
+          limit: options.limit || 20,
+          oldest: options.oldest,
+        },
+      );
+      return result.messages;
+    },
+
+    /**
+     * Send a message to a channel
+     */
+    async sendMessage(
+      channelId: string,
+      text: string,
+      options: { threadTs?: string; unfurlLinks?: boolean } = {},
+    ): Promise<{ ts: string; channel: string }> {
+      const result = await apiRequest<{ ts: string; channel: string }>(
+        "chat.postMessage",
+        {
+          channel: channelId,
+          text,
+          thread_ts: options.threadTs,
+          unfurl_links: options.unfurlLinks ?? true,
+        },
+      );
+      return result;
+    },
+
+    /**
+     * Get user info
+     */
+    async getUser(userId: string): Promise<SlackUser> {
+      const result = await apiRequest<{ user: SlackUser }>("users.info", {
+        user: userId,
+      });
+      return result.user;
+    },
+
+    /**
+     * Get thread replies
+     */
+    async getThread(
+      channelId: string,
+      threadTs: string,
+    ): Promise<SlackMessage[]> {
+      const result = await apiRequest<{ messages: SlackMessage[] }>(
+        "conversations.replies",
+        {
+          channel: channelId,
+          ts: threadTs,
+        },
+      );
+      return result.messages;
+    },
+
+    /**
+     * Search messages
+     */
+    async searchMessages(
+      query: string,
+      options: { count?: number } = {},
+    ): Promise<SlackMessage[]> {
+      const result = await apiRequest<{
+        messages: { matches: SlackMessage[] };
+      }>("search.messages", {
+        query,
+        count: options.count || 20,
+      });
+      return result.messages.matches;
+    },
+  };
+}
+
+export type SlackClient = ReturnType<typeof createSlackClient>;

package/dist/integrations/slack/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "veryfront",
-  "version": "0.0.44",
+  "version": "0.0.46",
   "description": "Zero-config React meta-framework for building agentic AI applications",
   "type": "module",
   "main": "./dist/index.js",