veryfront 0.0.56 → 0.0.58

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

@@ -5,7 +5,7 @@
  */
 
 import { createOAuthCallbackHandler, gmailConfig, memoryTokenStore } from "veryfront/oauth";
-import { tokenStore } from "../../../../../lib/token-store";
+import { tokenStore } from "../../../../../lib/token-store.ts";
 
 // Hybrid adapter: uses framework's memoryTokenStore for state (PKCE),
 // but user's tokenStore for actual token storage

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

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

@@ -1,11 +1,31 @@
 /**
  * HubSpot OAuth Callback
+ *
+ * Handles the OAuth callback from HubSpot and stores the tokens.
  */
 
 import { createOAuthCallbackHandler, hubspotConfig, 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(hubspotConfig, {
-  tokenStore: memoryTokenStore,
-  onSuccess: () => "/",
-  onError: () => "/",
+  tokenStore: hybridTokenStore,
 });

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

@@ -1,11 +1,31 @@
 /**
  * Intercom OAuth Callback
+ *
+ * Handles the OAuth callback from Intercom and stores the tokens.
  */
 
-import { intercomConfig, createOAuthCallbackHandler, memoryTokenStore } from "veryfront/oauth";
+import { createOAuthCallbackHandler, intercomConfig, 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(intercomConfig, {
-  tokenStore: memoryTokenStore,
-  onSuccess: () => "/",
-  onError: () => "/",
+  tokenStore: hybridTokenStore,
 });

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

@@ -1,11 +1,31 @@
 /**
  * Jira OAuth Callback
+ *
+ * Handles the OAuth callback from Atlassian and stores the tokens.
  */
 
 import { createOAuthCallbackHandler, jiraConfig, 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(jiraConfig, {
-  tokenStore: memoryTokenStore,
-  onSuccess: () => "/",
-  onError: () => "/",
+  tokenStore: hybridTokenStore,
 });

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

@@ -1,11 +1,31 @@
 /**
  * Linear OAuth Callback
+ *
+ * Handles the OAuth callback from Linear and stores the tokens.
  */
 
 import { createOAuthCallbackHandler, linearConfig, 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(linearConfig, {
-  tokenStore: memoryTokenStore,
-  onSuccess: () => "/",
-  onError: () => "/",
+  tokenStore: hybridTokenStore,
 });

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

@@ -1,11 +1,31 @@
 /**
  * Mailchimp OAuth Callback
+ *
+ * Handles the OAuth callback from Mailchimp and stores the tokens.
  */
 
 import { createOAuthCallbackHandler, mailchimpConfig, 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(mailchimpConfig, {
-  tokenStore: memoryTokenStore,
-  onSuccess: () => "/",
-  onError: () => "/",
+  tokenStore: hybridTokenStore,
 });

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

@@ -1,11 +1,31 @@
 /**
  * Monday.com OAuth Callback
+ *
+ * Handles the OAuth callback from Monday.com and stores the tokens.
  */
 
-import { mondayConfig, createOAuthCallbackHandler, memoryTokenStore } from "veryfront/oauth";
+import { createOAuthCallbackHandler, memoryTokenStore, mondayConfig } 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(mondayConfig, {
-  tokenStore: memoryTokenStore,
-  onSuccess: () => "/",
-  onError: () => "/",
+  tokenStore: hybridTokenStore,
 });

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

@@ -1,4 +1,4 @@
-import { setApiKey } from "../../../../lib/token-store";
+import { setApiKey } from "../../../../lib/token-store.ts";
 
 export async function POST(request: Request) {
   try {

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

@@ -1,11 +1,31 @@
 /**
  * Notion OAuth Callback
+ *
+ * Handles the OAuth callback from Notion and stores the tokens.
  */
 
 import { createOAuthCallbackHandler, memoryTokenStore, notionConfig } 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(notionConfig, {
-  tokenStore: memoryTokenStore,
-  onSuccess: () => "/",
-  onError: () => "/",
+  tokenStore: hybridTokenStore,
 });

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

@@ -1,11 +1,31 @@
 /**
  * OneDrive OAuth Callback
+ *
+ * Handles the OAuth callback from Microsoft and stores the tokens.
  */
 
 import { createOAuthCallbackHandler, memoryTokenStore, oneDriveConfig } 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(oneDriveConfig, {
-  tokenStore: memoryTokenStore,
-  onSuccess: () => "/",
-  onError: () => "/",
+  tokenStore: hybridTokenStore,
 });

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

@@ -1,11 +1,31 @@
 /**
  * Outlook OAuth Callback
+ *
+ * Handles the OAuth callback from Microsoft and stores the tokens.
  */
 
 import { createOAuthCallbackHandler, memoryTokenStore, outlookConfig } 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(outlookConfig, {
-  tokenStore: memoryTokenStore,
-  onSuccess: () => "/",
-  onError: () => "/",
+  tokenStore: hybridTokenStore,
 });

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

@@ -1,11 +1,31 @@
 /**
  * Pipedrive OAuth Callback
+ *
+ * Handles the OAuth callback from Pipedrive and stores the tokens.
  */
 
-import { pipedriveConfig, createOAuthCallbackHandler, memoryTokenStore } from "veryfront/oauth";
+import { createOAuthCallbackHandler, memoryTokenStore, pipedriveConfig } 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(pipedriveConfig, {
-  tokenStore: memoryTokenStore,
-  onSuccess: () => "/",
-  onError: () => "/",
+  tokenStore: hybridTokenStore,
 });

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

@@ -1,11 +1,31 @@
 /**
  * QuickBooks OAuth Callback
+ *
+ * Handles the OAuth callback from QuickBooks and stores the tokens.
  */
 
-import { quickbooksConfig, createOAuthCallbackHandler, memoryTokenStore } from "veryfront/oauth";
+import { createOAuthCallbackHandler, memoryTokenStore, quickbooksConfig } 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(quickbooksConfig, {
-  tokenStore: memoryTokenStore,
-  onSuccess: () => "/",
-  onError: () => "/",
+  tokenStore: hybridTokenStore,
 });

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

@@ -1,11 +1,31 @@
 /**
  * Salesforce OAuth Callback
+ *
+ * Handles the OAuth callback from Salesforce and stores the tokens.
  */
 
 import { createOAuthCallbackHandler, memoryTokenStore, salesforceConfig } 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(salesforceConfig, {
-  tokenStore: memoryTokenStore,
-  onSuccess: () => "/",
-  onError: () => "/",
+  tokenStore: hybridTokenStore,
 });