veryfront 0.0.56 → 0.0.57

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,
 });

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

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

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

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

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

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

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

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

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

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

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

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

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

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