veryfront 0.0.55 → 0.0.57

package/dist/integrations/_base/files/app/api/integrations/status/route.ts

@@ -5,7 +5,7 @@
  * Used by the setup guide to show which services are connected.
  */
 
-import { tokenStore } from "../../../../lib/token-store";
+import { tokenStore } from "../../../../lib/token-store.ts";
 
 // Define available integrations - will be populated based on project config
 const INTEGRATIONS = [

package/dist/integrations/_base/files/lib/token-store-examples.ts

@@ -13,7 +13,7 @@ import {
   decryptToken,
   type TokenStore,
   type OAuthToken,
-} from "./token-store";
+} from "./token-store.ts";
 
 // ============================================================================
 // Vercel KV Store

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

@@ -1,11 +1,31 @@
 /**
  * Airtable OAuth Callback
+ *
+ * Handles the OAuth callback from Airtable and stores the tokens.
  */
 
 import { airtableConfig, createOAuthCallbackHandler, memoryTokenStore } from "veryfront/oauth";
+import { tokenStore } from "../../../../../lib/token-store.ts";
+
+// Hybrid adapter: uses framework's memoryTokenStore for state (PKCE),
+// but user's tokenStore for actual token storage
+const hybridTokenStore = {
+  // Token methods - delegate to user's tokenStore
+  async getTokens(serviceId: string) {
+    return tokenStore.getToken("current-user", serviceId);
+  },
+  async setTokens(serviceId: string, tokens: { accessToken: string; refreshToken?: string; expiresAt?: number }) {
+    await tokenStore.setToken("current-user", serviceId, tokens);
+  },
+  async clearTokens(serviceId: string) {
+    await tokenStore.revokeToken("current-user", serviceId);
+  },
+  // State methods - delegate to framework's memoryTokenStore (shared with init route)
+  getState: (state: string) => memoryTokenStore.getState(state),
+  setState: (state: { state: string; codeVerifier?: string; createdAt: number }) => memoryTokenStore.setState(state),
+  clearState: (state: string) => memoryTokenStore.clearState(state),
+};
 
 export const GET = createOAuthCallbackHandler(airtableConfig, {
-  tokenStore: memoryTokenStore,
-  onSuccess: () => "/",
-  onError: () => "/",
+  tokenStore: hybridTokenStore,
 });

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

@@ -1,11 +1,31 @@
 /**
  * Asana OAuth Callback
+ *
+ * Handles the OAuth callback from Asana and stores the tokens.
  */
 
 import { asanaConfig, createOAuthCallbackHandler, memoryTokenStore } from "veryfront/oauth";
+import { tokenStore } from "../../../../../lib/token-store.ts";
+
+// Hybrid adapter: uses framework's memoryTokenStore for state (PKCE),
+// but user's tokenStore for actual token storage
+const hybridTokenStore = {
+  // Token methods - delegate to user's tokenStore
+  async getTokens(serviceId: string) {
+    return tokenStore.getToken("current-user", serviceId);
+  },
+  async setTokens(serviceId: string, tokens: { accessToken: string; refreshToken?: string; expiresAt?: number }) {
+    await tokenStore.setToken("current-user", serviceId, tokens);
+  },
+  async clearTokens(serviceId: string) {
+    await tokenStore.revokeToken("current-user", serviceId);
+  },
+  // State methods - delegate to framework's memoryTokenStore (shared with init route)
+  getState: (state: string) => memoryTokenStore.getState(state),
+  setState: (state: { state: string; codeVerifier?: string; createdAt: number }) => memoryTokenStore.setState(state),
+  clearState: (state: string) => memoryTokenStore.clearState(state),
+};
 
 export const GET = createOAuthCallbackHandler(asanaConfig, {
-  tokenStore: memoryTokenStore,
-  onSuccess: () => "/",
-  onError: () => "/",
+  tokenStore: hybridTokenStore,
 });

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

@@ -1,11 +1,31 @@
 /**
  * Bitbucket OAuth Callback
+ *
+ * Handles the OAuth callback from Atlassian and stores the tokens.
  */
 
 import { bitbucketConfig, createOAuthCallbackHandler, memoryTokenStore } from "veryfront/oauth";
+import { tokenStore } from "../../../../../lib/token-store.ts";
+
+// Hybrid adapter: uses framework's memoryTokenStore for state (PKCE),
+// but user's tokenStore for actual token storage
+const hybridTokenStore = {
+  // Token methods - delegate to user's tokenStore
+  async getTokens(serviceId: string) {
+    return tokenStore.getToken("current-user", serviceId);
+  },
+  async setTokens(serviceId: string, tokens: { accessToken: string; refreshToken?: string; expiresAt?: number }) {
+    await tokenStore.setToken("current-user", serviceId, tokens);
+  },
+  async clearTokens(serviceId: string) {
+    await tokenStore.revokeToken("current-user", serviceId);
+  },
+  // State methods - delegate to framework's memoryTokenStore (shared with init route)
+  getState: (state: string) => memoryTokenStore.getState(state),
+  setState: (state: { state: string; codeVerifier?: string; createdAt: number }) => memoryTokenStore.setState(state),
+  clearState: (state: string) => memoryTokenStore.clearState(state),
+};
 
 export const GET = createOAuthCallbackHandler(bitbucketConfig, {
-  tokenStore: memoryTokenStore,
-  onSuccess: () => "/",
-  onError: () => "/",
+  tokenStore: hybridTokenStore,
 });

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

@@ -1,11 +1,31 @@
 /**
  * Box OAuth Callback
+ *
+ * Handles the OAuth callback from Box and stores the tokens.
  */
 
 import { boxConfig, createOAuthCallbackHandler, memoryTokenStore } from "veryfront/oauth";
+import { tokenStore } from "../../../../../lib/token-store.ts";
+
+// Hybrid adapter: uses framework's memoryTokenStore for state (PKCE),
+// but user's tokenStore for actual token storage
+const hybridTokenStore = {
+  // Token methods - delegate to user's tokenStore
+  async getTokens(serviceId: string) {
+    return tokenStore.getToken("current-user", serviceId);
+  },
+  async setTokens(serviceId: string, tokens: { accessToken: string; refreshToken?: string; expiresAt?: number }) {
+    await tokenStore.setToken("current-user", serviceId, tokens);
+  },
+  async clearTokens(serviceId: string) {
+    await tokenStore.revokeToken("current-user", serviceId);
+  },
+  // State methods - delegate to framework's memoryTokenStore (shared with init route)
+  getState: (state: string) => memoryTokenStore.getState(state),
+  setState: (state: { state: string; codeVerifier?: string; createdAt: number }) => memoryTokenStore.setState(state),
+  clearState: (state: string) => memoryTokenStore.clearState(state),
+};
 
 export const GET = createOAuthCallbackHandler(boxConfig, {
-  tokenStore: memoryTokenStore,
-  onSuccess: () => "/",
-  onError: () => "/",
+  tokenStore: hybridTokenStore,
 });

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

@@ -1,11 +1,31 @@
 /**
  * Calendar OAuth Callback
+ *
+ * Handles the OAuth callback from Google and stores the tokens.
  */
 
 import { calendarConfig, createOAuthCallbackHandler, memoryTokenStore } from "veryfront/oauth";
+import { tokenStore } from "../../../../../lib/token-store.ts";
+
+// Hybrid adapter: uses framework's memoryTokenStore for state (PKCE),
+// but user's tokenStore for actual token storage
+const hybridTokenStore = {
+  // Token methods - delegate to user's tokenStore
+  async getTokens(serviceId: string) {
+    return tokenStore.getToken("current-user", serviceId);
+  },
+  async setTokens(serviceId: string, tokens: { accessToken: string; refreshToken?: string; expiresAt?: number }) {
+    await tokenStore.setToken("current-user", serviceId, tokens);
+  },
+  async clearTokens(serviceId: string) {
+    await tokenStore.revokeToken("current-user", serviceId);
+  },
+  // State methods - delegate to framework's memoryTokenStore (shared with init route)
+  getState: (state: string) => memoryTokenStore.getState(state),
+  setState: (state: { state: string; codeVerifier?: string; createdAt: number }) => memoryTokenStore.setState(state),
+  clearState: (state: string) => memoryTokenStore.clearState(state),
+};
 
 export const GET = createOAuthCallbackHandler(calendarConfig, {
-  tokenStore: memoryTokenStore,
-  onSuccess: () => "/",
-  onError: () => "/",
+  tokenStore: hybridTokenStore,
 });

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

@@ -1,11 +1,31 @@
 /**
  * ClickUp OAuth Callback
+ *
+ * Handles the OAuth callback from ClickUp and stores the tokens.
  */
 
 import { clickupConfig, createOAuthCallbackHandler, memoryTokenStore } from "veryfront/oauth";
+import { tokenStore } from "../../../../../lib/token-store.ts";
+
+// Hybrid adapter: uses framework's memoryTokenStore for state (PKCE),
+// but user's tokenStore for actual token storage
+const hybridTokenStore = {
+  // Token methods - delegate to user's tokenStore
+  async getTokens(serviceId: string) {
+    return tokenStore.getToken("current-user", serviceId);
+  },
+  async setTokens(serviceId: string, tokens: { accessToken: string; refreshToken?: string; expiresAt?: number }) {
+    await tokenStore.setToken("current-user", serviceId, tokens);
+  },
+  async clearTokens(serviceId: string) {
+    await tokenStore.revokeToken("current-user", serviceId);
+  },
+  // State methods - delegate to framework's memoryTokenStore (shared with init route)
+  getState: (state: string) => memoryTokenStore.getState(state),
+  setState: (state: { state: string; codeVerifier?: string; createdAt: number }) => memoryTokenStore.setState(state),
+  clearState: (state: string) => memoryTokenStore.clearState(state),
+};
 
 export const GET = createOAuthCallbackHandler(clickupConfig, {
-  tokenStore: memoryTokenStore,
-  onSuccess: () => "/",
-  onError: () => "/",
+  tokenStore: hybridTokenStore,
 });

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

@@ -1,11 +1,31 @@
 /**
  * Confluence OAuth Callback
+ *
+ * Handles the OAuth callback from Atlassian and stores the tokens.
  */
 
 import { confluenceConfig, createOAuthCallbackHandler, memoryTokenStore } from "veryfront/oauth";
+import { tokenStore } from "../../../../../lib/token-store.ts";
+
+// Hybrid adapter: uses framework's memoryTokenStore for state (PKCE),
+// but user's tokenStore for actual token storage
+const hybridTokenStore = {
+  // Token methods - delegate to user's tokenStore
+  async getTokens(serviceId: string) {
+    return tokenStore.getToken("current-user", serviceId);
+  },
+  async setTokens(serviceId: string, tokens: { accessToken: string; refreshToken?: string; expiresAt?: number }) {
+    await tokenStore.setToken("current-user", serviceId, tokens);
+  },
+  async clearTokens(serviceId: string) {
+    await tokenStore.revokeToken("current-user", serviceId);
+  },
+  // State methods - delegate to framework's memoryTokenStore (shared with init route)
+  getState: (state: string) => memoryTokenStore.getState(state),
+  setState: (state: { state: string; codeVerifier?: string; createdAt: number }) => memoryTokenStore.setState(state),
+  clearState: (state: string) => memoryTokenStore.clearState(state),
+};
 
 export const GET = createOAuthCallbackHandler(confluenceConfig, {
-  tokenStore: memoryTokenStore,
-  onSuccess: () => "/",
-  onError: () => "/",
+  tokenStore: hybridTokenStore,
 });

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

@@ -1,11 +1,31 @@
 /**
  * Discord OAuth Callback
+ *
+ * Handles the OAuth callback from Discord and stores the tokens.
  */
 
 import { createOAuthCallbackHandler, discordConfig, memoryTokenStore } from "veryfront/oauth";
+import { tokenStore } from "../../../../../lib/token-store.ts";
+
+// Hybrid adapter: uses framework's memoryTokenStore for state (PKCE),
+// but user's tokenStore for actual token storage
+const hybridTokenStore = {
+  // Token methods - delegate to user's tokenStore
+  async getTokens(serviceId: string) {
+    return tokenStore.getToken("current-user", serviceId);
+  },
+  async setTokens(serviceId: string, tokens: { accessToken: string; refreshToken?: string; expiresAt?: number }) {
+    await tokenStore.setToken("current-user", serviceId, tokens);
+  },
+  async clearTokens(serviceId: string) {
+    await tokenStore.revokeToken("current-user", serviceId);
+  },
+  // State methods - delegate to framework's memoryTokenStore (shared with init route)
+  getState: (state: string) => memoryTokenStore.getState(state),
+  setState: (state: { state: string; codeVerifier?: string; createdAt: number }) => memoryTokenStore.setState(state),
+  clearState: (state: string) => memoryTokenStore.clearState(state),
+};
 
 export const GET = createOAuthCallbackHandler(discordConfig, {
-  tokenStore: memoryTokenStore,
-  onSuccess: () => "/",
-  onError: () => "/",
+  tokenStore: hybridTokenStore,
 });

package/dist/integrations/docs-google/files/app/api/auth/docs-google/callback/route.ts

@@ -1,11 +1,31 @@
 /**
  * Google Docs OAuth Callback
+ *
+ * Handles the OAuth callback from Google and stores the tokens.
  */
 
-import { createOAuthCallbackHandler, memoryTokenStore, docsGoogleConfig } from "veryfront/oauth";
+import { createOAuthCallbackHandler, docsGoogleConfig, memoryTokenStore } from "veryfront/oauth";
+import { tokenStore } from "../../../../../lib/token-store.ts";
+
+// Hybrid adapter: uses framework's memoryTokenStore for state (PKCE),
+// but user's tokenStore for actual token storage
+const hybridTokenStore = {
+  // Token methods - delegate to user's tokenStore
+  async getTokens(serviceId: string) {
+    return tokenStore.getToken("current-user", serviceId);
+  },
+  async setTokens(serviceId: string, tokens: { accessToken: string; refreshToken?: string; expiresAt?: number }) {
+    await tokenStore.setToken("current-user", serviceId, tokens);
+  },
+  async clearTokens(serviceId: string) {
+    await tokenStore.revokeToken("current-user", serviceId);
+  },
+  // State methods - delegate to framework's memoryTokenStore (shared with init route)
+  getState: (state: string) => memoryTokenStore.getState(state),
+  setState: (state: { state: string; codeVerifier?: string; createdAt: number }) => memoryTokenStore.setState(state),
+  clearState: (state: string) => memoryTokenStore.clearState(state),
+};
 
 export const GET = createOAuthCallbackHandler(docsGoogleConfig, {
-  tokenStore: memoryTokenStore,
-  onSuccess: () => "/",
-  onError: () => "/",
+  tokenStore: hybridTokenStore,
 });

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

@@ -1,11 +1,31 @@
 /**
  * Google Drive OAuth Callback
+ *
+ * Handles the OAuth callback from Google and stores the tokens.
  */
 
-import { createOAuthCallbackHandler, memoryTokenStore, driveConfig } from "veryfront/oauth";
+import { createOAuthCallbackHandler, driveConfig, memoryTokenStore } from "veryfront/oauth";
+import { tokenStore } from "../../../../../lib/token-store.ts";
+
+// Hybrid adapter: uses framework's memoryTokenStore for state (PKCE),
+// but user's tokenStore for actual token storage
+const hybridTokenStore = {
+  // Token methods - delegate to user's tokenStore
+  async getTokens(serviceId: string) {
+    return tokenStore.getToken("current-user", serviceId);
+  },
+  async setTokens(serviceId: string, tokens: { accessToken: string; refreshToken?: string; expiresAt?: number }) {
+    await tokenStore.setToken("current-user", serviceId, tokens);
+  },
+  async clearTokens(serviceId: string) {
+    await tokenStore.revokeToken("current-user", serviceId);
+  },
+  // State methods - delegate to framework's memoryTokenStore (shared with init route)
+  getState: (state: string) => memoryTokenStore.getState(state),
+  setState: (state: { state: string; codeVerifier?: string; createdAt: number }) => memoryTokenStore.setState(state),
+  clearState: (state: string) => memoryTokenStore.clearState(state),
+};
 
 export const GET = createOAuthCallbackHandler(driveConfig, {
-  tokenStore: memoryTokenStore,
-  onSuccess: () => "/",
-  onError: () => "/",
+  tokenStore: hybridTokenStore,
 });

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

@@ -1,11 +1,31 @@
 /**
  * Dropbox OAuth Callback
+ *
+ * Handles the OAuth callback from Dropbox and stores the tokens.
  */
 
 import { createOAuthCallbackHandler, dropboxConfig, memoryTokenStore } from "veryfront/oauth";
+import { tokenStore } from "../../../../../lib/token-store.ts";
+
+// Hybrid adapter: uses framework's memoryTokenStore for state (PKCE),
+// but user's tokenStore for actual token storage
+const hybridTokenStore = {
+  // Token methods - delegate to user's tokenStore
+  async getTokens(serviceId: string) {
+    return tokenStore.getToken("current-user", serviceId);
+  },
+  async setTokens(serviceId: string, tokens: { accessToken: string; refreshToken?: string; expiresAt?: number }) {
+    await tokenStore.setToken("current-user", serviceId, tokens);
+  },
+  async clearTokens(serviceId: string) {
+    await tokenStore.revokeToken("current-user", serviceId);
+  },
+  // State methods - delegate to framework's memoryTokenStore (shared with init route)
+  getState: (state: string) => memoryTokenStore.getState(state),
+  setState: (state: { state: string; codeVerifier?: string; createdAt: number }) => memoryTokenStore.setState(state),
+  clearState: (state: string) => memoryTokenStore.clearState(state),
+};
 
 export const GET = createOAuthCallbackHandler(dropboxConfig, {
-  tokenStore: memoryTokenStore,
-  onSuccess: () => "/",
-  onError: () => "/",
+  tokenStore: hybridTokenStore,
 });

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

@@ -1,11 +1,31 @@
 /**
  * Figma OAuth Callback
+ *
+ * Handles the OAuth callback from Figma and stores the tokens.
  */
 
 import { createOAuthCallbackHandler, figmaConfig, memoryTokenStore } from "veryfront/oauth";
+import { tokenStore } from "../../../../../lib/token-store.ts";
+
+// Hybrid adapter: uses framework's memoryTokenStore for state (PKCE),
+// but user's tokenStore for actual token storage
+const hybridTokenStore = {
+  // Token methods - delegate to user's tokenStore
+  async getTokens(serviceId: string) {
+    return tokenStore.getToken("current-user", serviceId);
+  },
+  async setTokens(serviceId: string, tokens: { accessToken: string; refreshToken?: string; expiresAt?: number }) {
+    await tokenStore.setToken("current-user", serviceId, tokens);
+  },
+  async clearTokens(serviceId: string) {
+    await tokenStore.revokeToken("current-user", serviceId);
+  },
+  // State methods - delegate to framework's memoryTokenStore (shared with init route)
+  getState: (state: string) => memoryTokenStore.getState(state),
+  setState: (state: { state: string; codeVerifier?: string; createdAt: number }) => memoryTokenStore.setState(state),
+  clearState: (state: string) => memoryTokenStore.clearState(state),
+};
 
 export const GET = createOAuthCallbackHandler(figmaConfig, {
-  tokenStore: memoryTokenStore,
-  onSuccess: () => "/",
-  onError: () => "/",
+  tokenStore: hybridTokenStore,
 });

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

@@ -1,11 +1,31 @@
 /**
  * Freshdesk OAuth Callback
+ *
+ * Handles the OAuth callback from Freshdesk and stores the tokens.
  */
 
-import { freshdeskConfig, createOAuthCallbackHandler, memoryTokenStore } from "veryfront/oauth";
+import { createOAuthCallbackHandler, freshdeskConfig, memoryTokenStore } from "veryfront/oauth";
+import { tokenStore } from "../../../../../lib/token-store.ts";
+
+// Hybrid adapter: uses framework's memoryTokenStore for state (PKCE),
+// but user's tokenStore for actual token storage
+const hybridTokenStore = {
+  // Token methods - delegate to user's tokenStore
+  async getTokens(serviceId: string) {
+    return tokenStore.getToken("current-user", serviceId);
+  },
+  async setTokens(serviceId: string, tokens: { accessToken: string; refreshToken?: string; expiresAt?: number }) {
+    await tokenStore.setToken("current-user", serviceId, tokens);
+  },
+  async clearTokens(serviceId: string) {
+    await tokenStore.revokeToken("current-user", serviceId);
+  },
+  // State methods - delegate to framework's memoryTokenStore (shared with init route)
+  getState: (state: string) => memoryTokenStore.getState(state),
+  setState: (state: { state: string; codeVerifier?: string; createdAt: number }) => memoryTokenStore.setState(state),
+  clearState: (state: string) => memoryTokenStore.clearState(state),
+};
 
 export const GET = createOAuthCallbackHandler(freshdeskConfig, {
-  tokenStore: memoryTokenStore,
-  onSuccess: () => "/",
-  onError: () => "/",
+  tokenStore: hybridTokenStore,
 });

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

@@ -1,11 +1,31 @@
 /**
  * GitHub OAuth Callback
+ *
+ * Handles the OAuth callback from GitHub and stores the tokens.
  */
 
 import { createOAuthCallbackHandler, githubConfig, memoryTokenStore } from "veryfront/oauth";
+import { tokenStore } from "../../../../../lib/token-store.ts";
+
+// Hybrid adapter: uses framework's memoryTokenStore for state (PKCE),
+// but user's tokenStore for actual token storage
+const hybridTokenStore = {
+  // Token methods - delegate to user's tokenStore
+  async getTokens(serviceId: string) {
+    return tokenStore.getToken("current-user", serviceId);
+  },
+  async setTokens(serviceId: string, tokens: { accessToken: string; refreshToken?: string; expiresAt?: number }) {
+    await tokenStore.setToken("current-user", serviceId, tokens);
+  },
+  async clearTokens(serviceId: string) {
+    await tokenStore.revokeToken("current-user", serviceId);
+  },
+  // State methods - delegate to framework's memoryTokenStore (shared with init route)
+  getState: (state: string) => memoryTokenStore.getState(state),
+  setState: (state: { state: string; codeVerifier?: string; createdAt: number }) => memoryTokenStore.setState(state),
+  clearState: (state: string) => memoryTokenStore.clearState(state),
+};
 
 export const GET = createOAuthCallbackHandler(githubConfig, {
-  tokenStore: memoryTokenStore,
-  onSuccess: () => "/",
-  onError: () => "/",
+  tokenStore: hybridTokenStore,
 });

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

@@ -1,11 +1,31 @@
 /**
  * GitLab OAuth Callback
+ *
+ * Handles the OAuth callback from GitLab and stores the tokens.
  */
 
 import { createOAuthCallbackHandler, gitlabConfig, memoryTokenStore } from "veryfront/oauth";
+import { tokenStore } from "../../../../../lib/token-store.ts";
+
+// Hybrid adapter: uses framework's memoryTokenStore for state (PKCE),
+// but user's tokenStore for actual token storage
+const hybridTokenStore = {
+  // Token methods - delegate to user's tokenStore
+  async getTokens(serviceId: string) {
+    return tokenStore.getToken("current-user", serviceId);
+  },
+  async setTokens(serviceId: string, tokens: { accessToken: string; refreshToken?: string; expiresAt?: number }) {
+    await tokenStore.setToken("current-user", serviceId, tokens);
+  },
+  async clearTokens(serviceId: string) {
+    await tokenStore.revokeToken("current-user", serviceId);
+  },
+  // State methods - delegate to framework's memoryTokenStore (shared with init route)
+  getState: (state: string) => memoryTokenStore.getState(state),
+  setState: (state: { state: string; codeVerifier?: string; createdAt: number }) => memoryTokenStore.setState(state),
+  clearState: (state: string) => memoryTokenStore.clearState(state),
+};
 
 export const GET = createOAuthCallbackHandler(gitlabConfig, {
-  tokenStore: memoryTokenStore,
-  onSuccess: () => "/",
-  onError: () => "/",
+  tokenStore: hybridTokenStore,
 });

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

@@ -1,13 +1,31 @@
 /**
  * Gmail OAuth Callback
  *
- * Uses the veryfront/oauth module for simplified OAuth callback handling.
+ * Handles the OAuth callback from Google and stores the tokens.
  */
 
 import { createOAuthCallbackHandler, gmailConfig, memoryTokenStore } from "veryfront/oauth";
+import { tokenStore } from "../../../../../lib/token-store.ts";
+
+// Hybrid adapter: uses framework's memoryTokenStore for state (PKCE),
+// but user's tokenStore for actual token storage
+const hybridTokenStore = {
+  // Token methods - delegate to user's tokenStore
+  async getTokens(serviceId: string) {
+    return tokenStore.getToken("current-user", serviceId);
+  },
+  async setTokens(serviceId: string, tokens: { accessToken: string; refreshToken?: string; expiresAt?: number }) {
+    await tokenStore.setToken("current-user", serviceId, tokens);
+  },
+  async clearTokens(serviceId: string) {
+    await tokenStore.revokeToken("current-user", serviceId);
+  },
+  // State methods - delegate to framework's memoryTokenStore (shared with init route)
+  getState: (state: string) => memoryTokenStore.getState(state),
+  setState: (state: { state: string; codeVerifier?: string; createdAt: number }) => memoryTokenStore.setState(state),
+  clearState: (state: string) => memoryTokenStore.clearState(state),
+};
 
 export const GET = createOAuthCallbackHandler(gmailConfig, {
-  tokenStore: memoryTokenStore,
-  onSuccess: () => "/",
-  onError: () => "/",
+  tokenStore: hybridTokenStore,
 });

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

@@ -5,7 +5,8 @@
  * using the veryfront/oauth module for authentication.
  */
 
-import { gmailConfig, memoryTokenStore, OAuthService } from "veryfront/oauth";
+import { gmailConfig, OAuthService } from "veryfront/oauth";
+import { tokenStore } from "./token-store.ts";
 
 export interface GmailMessage {
   id: string;
@@ -39,8 +40,25 @@ export interface SendEmailOptions {
   isHtml?: boolean;
 }
 
-// Create Gmail service using the OAuth module
-const gmailService = new OAuthService(gmailConfig, memoryTokenStore);
+// Adapter to bridge user's tokenStore with framework's TokenStore interface
+const tokenStoreAdapter = {
+  async getTokens(serviceId: string) {
+    return tokenStore.getToken("current-user", serviceId);
+  },
+  async setTokens(serviceId: string, tokens: { accessToken: string; refreshToken?: string; expiresAt?: number }) {
+    await tokenStore.setToken("current-user", serviceId, tokens);
+  },
+  async clearTokens(serviceId: string) {
+    await tokenStore.revokeToken("current-user", serviceId);
+  },
+  // State methods not needed for API client
+  async getState() { return null; },
+  async setState() {},
+  async clearState() {},
+};
+
+// Create Gmail service using the user's token store
+const gmailService = new OAuthService(gmailConfig, tokenStoreAdapter);
 
 /**
  * Create a Gmail client for API operations