thepopebot 1.2.73 → 1.2.74-beta.10

package/api/index.js

@@ -7,8 +7,9 @@ import { chat, summarizeJob } from '../lib/ai/index.js';
 import { createNotification } from '../lib/db/notifications.js';
 import { loadTriggers } from '../lib/triggers.js';
 import { verifyApiKey } from '../lib/db/api-keys.js';
+import { getConfig } from '../lib/config.js';
 
-// Bot token from env, can be overridden by /telegram/register
+// Bot token — resolved from DB/env, can be overridden by /telegram/register
 let telegramBotToken = null;
 
 // Cached trigger firing function (initialized on first request)
@@ -16,7 +17,7 @@ let _fireTriggers = null;
 
 function getTelegramBotToken() {
   if (!telegramBotToken) {
-    telegramBotToken = process.env.TELEGRAM_BOT_TOKEN || null;
+    telegramBotToken = getConfig('TELEGRAM_BOT_TOKEN') || null;
   }
   return telegramBotToken;
 }
@@ -103,7 +104,7 @@ async function handleTelegramRegister(request) {
   }
 
   try {
-    const result = await setWebhook(bot_token, webhook_url, process.env.TELEGRAM_WEBHOOK_SECRET);
+    const result = await setWebhook(bot_token, webhook_url, getConfig('TELEGRAM_WEBHOOK_SECRET'));
     telegramBotToken = bot_token;
     return Response.json({ success: true, result });
   } catch (err) {
@@ -159,7 +160,7 @@ async function processChannelMessage(adapter, normalized) {
 }
 
 async function handleGithubWebhook(request) {
-  const { GH_WEBHOOK_SECRET } = process.env;
+  const GH_WEBHOOK_SECRET = getConfig('GH_WEBHOOK_SECRET');
 
   // Validate webhook secret (timing-safe, required)
   if (!GH_WEBHOOK_SECRET || !safeCompare(request.headers.get('x-github-webhook-secret-token'), GH_WEBHOOK_SECRET)) {

package/bin/cli.js

@@ -248,22 +248,12 @@ async function init() {
       name: dirName,
       private: true,
       scripts: {
-        dev: 'next dev --turbopack',
-        build: 'next build',
-        start: 'next start',
         setup: 'thepopebot setup',
         'setup-telegram': 'thepopebot setup-telegram',
         'reset-auth': 'thepopebot reset-auth',
       },
       dependencies: {
         thepopebot: thepopebotDep,
-        next: '^15.5.12',
-        'next-auth': '5.0.0-beta.30',
-        'next-themes': '^0.4.0',
-        react: '^19.0.0',
-        'react-dom': '^19.0.0',
-        tailwindcss: '^4.0.0',
-        '@tailwindcss/postcss': '^4.0.0',
       },
     };
     fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
@@ -354,6 +344,10 @@ async function init() {
 AUTH_SECRET=${authSecret}
 AUTH_TRUST_HOST=true
 THEPOPEBOT_VERSION=${version}
+
+# Uncomment to use a custom docker-compose file that won't be overwritten by upgrades.
+# Edit docker-compose.custom.yml with your changes, then uncomment:
+# COMPOSE_FILE=docker-compose.custom.yml
 `;
     fs.writeFileSync(envPath, seedEnv);
     console.log(`  Created .env (AUTH_SECRET, THEPOPEBOT_VERSION=${version})`);
@@ -618,24 +612,6 @@ async function upgrade() {
     process.exit(1);
   }
 
-  // --- Clear .next ---
-  try {
-    fs.rmSync(path.join(cwd, '.next'), { recursive: true, force: true });
-  } catch {}
-
-  // --- Build ---
-  console.log('\n  Building...\n');
-  try {
-    execSync('npm run build', { stdio: 'inherit', cwd });
-  } catch {
-    console.error('\n  Build failed. The upgrade has been applied but the project does not build.');
-    console.error('  Fix the build errors, then run:\n');
-    console.error(`    npm run build`);
-    console.error(`    git add -A && git commit -m "upgrade thepopebot to ${targetVersion}"`);
-    console.error('    git push\n');
-    process.exit(1);
-  }
-
   // --- Commit upgrade ---
   const changes = execSync('git status --porcelain', { encoding: 'utf8', cwd }).trim();
   if (changes) {
@@ -664,8 +640,8 @@ async function upgrade() {
     try {
       const running = execSync('docker compose ps --status running -q', { encoding: 'utf8', cwd }).trim();
       if (running) {
-        console.log('  Restarting Docker containers...\n');
-        execSync('docker compose down && docker compose up -d', { stdio: 'inherit', cwd });
+        console.log('  Pulling new image and restarting Docker containers...\n');
+        execSync('docker compose pull event-handler && docker compose up -d --force-recreate event-handler', { stdio: 'inherit', cwd });
       }
     } catch {
       // Docker not available or not running — skip

package/bin/docker-build.js

@@ -26,33 +26,33 @@ const REPO = 'stephengpope/thepopebot';
 const IMAGES = [
   {
     name: 'pi-coding-agent-job',
-    context: 'templates/docker/pi-coding-agent-job',
-    dockerfile: 'templates/docker/pi-coding-agent-job/Dockerfile',
+    context: 'docker/pi-coding-agent-job',
+    dockerfile: 'docker/pi-coding-agent-job/Dockerfile',
   },
   {
     name: 'claude-code-job',
-    context: 'templates/docker/claude-code-job',
-    dockerfile: 'templates/docker/claude-code-job/Dockerfile',
+    context: 'docker/claude-code-job',
+    dockerfile: 'docker/claude-code-job/Dockerfile',
   },
   {
     name: 'claude-code-workspace',
-    context: 'templates/docker/claude-code-workspace',
-    dockerfile: 'templates/docker/claude-code-workspace/Dockerfile',
+    context: 'docker/claude-code-workspace',
+    dockerfile: 'docker/claude-code-workspace/Dockerfile',
   },
   {
     name: 'claude-code-headless',
-    context: 'templates/docker/claude-code-headless',
-    dockerfile: 'templates/docker/claude-code-headless/Dockerfile',
+    context: 'docker/claude-code-headless',
+    dockerfile: 'docker/claude-code-headless/Dockerfile',
   },
   {
     name: 'claude-code-cluster-worker',
-    context: 'templates/docker/claude-code-cluster-worker',
-    dockerfile: 'templates/docker/claude-code-cluster-worker/Dockerfile',
+    context: 'docker/claude-code-cluster-worker',
+    dockerfile: 'docker/claude-code-cluster-worker/Dockerfile',
   },
   {
     name: 'event-handler',
     context: '.',
-    dockerfile: 'templates/docker/event-handler/Dockerfile',
+    dockerfile: 'docker/event-handler/Dockerfile',
   },
 ];
 

package/bin/managed-paths.js

@@ -4,11 +4,10 @@
 // Paths ending with '/' are directories (all contents are managed).
 export const MANAGED_PATHS = [
   '.github/workflows/',
-  'docker/',
+
   'docker-compose.yml',
   '.dockerignore',
   'CLAUDE.md',
-  'app/',
 ];
 
 export function isManaged(relPath) {

package/bin/sync.js

@@ -29,10 +29,9 @@
  *   2. npm pack → copy tarball to project
  *   3. mirrorTemplates() — overwrite + delete stale
  *   4. npm install tarball on host (--no-save)
- *   5. Next.js build on host
- *   6. Docker image build (patches Dockerfile for local tarball)
- *   7. docker compose up -d -V event-handler
- *   8. Cleanup tarball
+ *   5. Docker image build (patches Dockerfile for local tarball, includes Next.js build)
+ *   6. docker compose up -d -V event-handler
+ *   7. Cleanup tarball
  */
 import { execSync } from 'child_process';
 import fs from 'fs';
@@ -158,7 +157,7 @@ function mirrorTemplates(projectPath) {
 function buildDockerImage(projectPath) {
   console.log('\n  Building Docker event handler image...');
 
-  const dockerfilePath = path.join(projectPath, 'docker', 'event-handler', 'Dockerfile');
+  const dockerfilePath = path.join(PACKAGE_DIR, 'docker', 'event-handler', 'Dockerfile');
   let dockerfile = fs.readFileSync(dockerfilePath, 'utf8');
 
   // Add COPY for tarball after the package.json COPY line in builder stage
@@ -169,24 +168,30 @@ function buildDockerImage(projectPath) {
 
   // Replace npm install from registry with local tarball install
   dockerfile = dockerfile.replace(
-    /RUN npm install --omit=dev && \\\n\s+npm install --no-save thepopebot@\$\(node -p "require\('\.\/package\.json'\)\.version"\)/,
-    'RUN npm install --omit=dev && \\\n    npm install --no-save /tmp/thepopebot.tgz && rm /tmp/thepopebot.tgz'
+    /RUN TPB_VERSION=.*\n\s+echo.*\n\s+npm install --no-save "thepopebot@\$\{TPB_VERSION\}" tailwindcss @tailwindcss\/postcss/,
+    'RUN echo \'{"private":true}\' > package.json && \\\n    npm install --no-save /tmp/thepopebot.tgz tailwindcss @tailwindcss/postcss && \\\n    rm /tmp/thepopebot.tgz'
   );
 
-  // Fix template paths for project context (templates/docker/... → docker/...)
-  dockerfile = dockerfile.replace(/COPY templates\//g, 'COPY ');
-
   // Read version from package.json
   const pkg = JSON.parse(fs.readFileSync(path.join(PACKAGE_DIR, 'package.json'), 'utf8'));
   const version = pkg.version;
   const imageTag = `stephengpope/thepopebot:event-handler-${version}`;
 
-  // Build using stdin Dockerfile with project dir as context (no cache to ensure fresh package)
-  execSync(`docker build --no-cache -f - -t ${imageTag} .`, {
-    input: dockerfile,
-    stdio: ['pipe', 'inherit', 'inherit'],
-    cwd: projectPath,
-  });
+  // Copy web/ to project for Docker build context
+  const webSrc = path.join(PACKAGE_DIR, 'web');
+  const webDest = path.join(projectPath, 'web');
+  fs.cpSync(webSrc, webDest, { recursive: true });
+
+  try {
+    // Build using stdin Dockerfile with project dir as context (no cache to ensure fresh package)
+    execSync(`docker build --no-cache -f - -t ${imageTag} .`, {
+      input: dockerfile,
+      stdio: ['pipe', 'inherit', 'inherit'],
+      cwd: projectPath,
+    });
+  } finally {
+    fs.rmSync(webDest, { recursive: true, force: true });
+  }
 
   // Update THEPOPEBOT_VERSION in .env
   const envPath = path.join(projectPath, '.env');
@@ -239,15 +244,10 @@ export async function sync(projectPath) {
     console.log('\n  Installing package on host...');
     execSync(`npm install --no-save ${tarballDest}`, { stdio: 'inherit', cwd: projectPath });
 
-    // 5. Build Next.js on host (avoids OOM inside container)
-    console.log('\n  Building Next.js...');
-    fs.rmSync(path.join(projectPath, '.next'), { recursive: true, force: true });
-    execSync('npm run build', { stdio: 'inherit', cwd: projectPath });
-
-    // 6. Build Docker image with patched Dockerfile
+    // 5. Build Docker image with patched Dockerfile (includes Next.js build)
     buildDockerImage(projectPath);
 
-    // 7. Restart container (fresh start picks up .next via volume mount)
+    // 6. Restart container with new image
     console.log('\n  Restarting event handler...');
     execSync('docker compose up -d -V event-handler', { stdio: 'inherit', cwd: projectPath });
 

package/config/instrumentation.js

@@ -43,6 +43,14 @@ export async function register() {
   const { initDatabase } = await import('../lib/db/index.js');
   initDatabase();
 
+  // Migrate env vars to DB on first run (idempotent)
+  try {
+    const { migrateEnvToDb } = await import('../lib/db/config.js');
+    migrateEnvToDb();
+  } catch (err) {
+    console.warn('Config migration:', err.message);
+  }
+
   // Start cron scheduler
   const { loadCrons } = await import('../lib/cron.js');
   loadCrons();

package/lib/ai/CLAUDE.md

@@ -30,11 +30,13 @@ Two agent types, both using `createReactAgent` from `@langchain/langgraph/prebui
 |----------|----------------|---------------|-------------|
 | Anthropic | `anthropic` (default) | `claude-sonnet-4-20250514` | `ANTHROPIC_API_KEY` |
 | OpenAI | `openai` | `gpt-4o` | `OPENAI_API_KEY` |
-| Google | `google` | `gemini-2.5-pro` | `GOOGLE_API_KEY` |
+| Google | `google` | `gemini-2.5-flash` | `GOOGLE_API_KEY` |
 | Custom | `custom` | — | `OPENAI_BASE_URL`, `CUSTOM_API_KEY` (optional) |
 
 `LLM_MAX_TOKENS` defaults to 4096. Web search available for `anthropic` and `openai` providers only (disable with `WEB_SEARCH=false`).
 
+> **Google model compatibility note:** `gemini-2.5-pro` and all `gemini-3.*` models require `thought_signature` round-tripping that `@langchain/google-genai` does not yet support. Setting `LLM_MODEL` to one of these will automatically fall back to `gemini-2.5-flash` at runtime with a warning. Supported Gemini models: `gemini-2.5-flash` (default), `gemini-2.5-flash-lite`. Full support for thinking models is tracked in issue #201.
+
 ## Chat Streaming
 
 `chatStream()` in `index.js` yields chunks: `{ type: 'text', content }`, `{ type: 'tool-call', name, args }`, `{ type: 'tool-result', name, result }`. Called by `lib/chat/api.js` (the `/stream/chat` endpoint).

package/lib/ai/model.js

@@ -1,36 +1,43 @@
 import { ChatAnthropic } from '@langchain/anthropic';
+import { getConfig } from '../config.js';
+import { BUILTIN_PROVIDERS } from '../llm-providers.js';
 
-const DEFAULT_MODELS = {
-  anthropic: 'claude-sonnet-4-20250514',
-  openai: 'gpt-4o',
-  google: 'gemini-2.5-pro',
-};
+// These models require thought_signature round-tripping which @langchain/google-genai doesn't support.
+// Auto-replace with gemini-2.5-flash until we migrate to @langchain/google (see issue #201).
+const GEMINI_UNSUPPORTED_MODELS = ['gemini-2.5-pro', 'gemini-3'];
+const GEMINI_FALLBACK = 'gemini-2.5-flash';
 
 /**
- * Create a LangChain chat model based on environment configuration.
- *
- * Config env vars:
- *   LLM_PROVIDER    — "anthropic" (default), "openai", "google"
- *   LLM_MODEL       — Model name override (e.g. "claude-sonnet-4-20250514")
- *   ANTHROPIC_API_KEY — Required for anthropic provider
- *   OPENAI_API_KEY   — Required for openai provider (optional with OPENAI_BASE_URL)
- *   OPENAI_BASE_URL  — Custom OpenAI-compatible base URL (e.g. http://localhost:11434/v1 for Ollama)
- *   GOOGLE_API_KEY   — Required for google provider
+ * Create a LangChain chat model based on DB/env configuration.
  *
  * @param {object} [options]
- * @param {number} [options.maxTokens=4096] - Max tokens for the response
+ * @param {number} [options.maxTokens] - Max tokens for the response
  * @returns {import('@langchain/core/language_models/chat_models').BaseChatModel}
  */
 export async function createModel(options = {}) {
-  const provider = process.env.LLM_PROVIDER || 'anthropic';
-  const modelName = process.env.LLM_MODEL || DEFAULT_MODELS[provider] || DEFAULT_MODELS.anthropic;
-  const maxTokens = options.maxTokens || Number(process.env.LLM_MAX_TOKENS) || 4096;
+  const provider = getConfig('LLM_PROVIDER');
+  const modelName = getConfig('LLM_MODEL');
+  const maxTokens = options.maxTokens || Number(getConfig('LLM_MAX_TOKENS')) || 4096;
+
+  // Custom provider (not in BUILTIN_PROVIDERS) → OpenAI-compatible
+  if (!BUILTIN_PROVIDERS[provider]) {
+    const { ChatOpenAI } = await import('@langchain/openai');
+    const { getCustomProvider } = await import('../db/config.js');
+    const custom = getCustomProvider(provider);
+    if (!custom) throw new Error(`Unknown LLM provider: ${provider}`);
+    const config = { modelName: custom.model || modelName, maxTokens };
+    config.apiKey = custom.apiKey || 'not-needed';
+    if (custom.baseUrl) {
+      config.configuration = { baseURL: custom.baseUrl };
+    }
+    return new ChatOpenAI(config);
+  }
 
   switch (provider) {
     case 'anthropic': {
-      const apiKey = process.env.ANTHROPIC_API_KEY;
+      const apiKey = getConfig('ANTHROPIC_API_KEY');
       if (!apiKey) {
-        throw new Error('ANTHROPIC_API_KEY environment variable is required');
+        throw new Error('ANTHROPIC_API_KEY is required — set it on the Settings > Chat page');
       }
       return new ChatAnthropic({
         modelName,
@@ -38,15 +45,12 @@ export async function createModel(options = {}) {
         anthropicApiKey: apiKey,
       });
     }
-    case 'custom':
     case 'openai': {
       const { ChatOpenAI } = await import('@langchain/openai');
-      const apiKey = provider === 'custom'
-        ? (process.env.CUSTOM_API_KEY || 'not-needed')
-        : process.env.OPENAI_API_KEY;
-      const baseURL = process.env.OPENAI_BASE_URL;
+      const apiKey = getConfig('OPENAI_API_KEY');
+      const baseURL = getConfig('OPENAI_BASE_URL');
       if (!apiKey && !baseURL) {
-        throw new Error('OPENAI_API_KEY environment variable is required (or set OPENAI_BASE_URL for local models)');
+        throw new Error('OPENAI_API_KEY is required — set it on the Settings > Chat page');
       }
       const config = { modelName, maxTokens };
       config.apiKey = apiKey || 'not-needed';
@@ -57,12 +61,21 @@ export async function createModel(options = {}) {
     }
     case 'google': {
       const { ChatGoogleGenerativeAI } = await import('@langchain/google-genai');
-      const apiKey = process.env.GOOGLE_API_KEY;
+      const apiKey = getConfig('GOOGLE_API_KEY');
       if (!apiKey) {
-        throw new Error('GOOGLE_API_KEY environment variable is required');
+        throw new Error('GOOGLE_API_KEY is required — set it on the Settings > Chat page');
+      }
+      let resolvedModel = modelName;
+      const isUnsupported = GEMINI_UNSUPPORTED_MODELS.some(m => resolvedModel.startsWith(m));
+      if (isUnsupported) {
+        console.warn(
+          `[model] ${resolvedModel} requires thought_signature support not yet available in @langchain/google-genai. ` +
+          `Falling back to ${GEMINI_FALLBACK}. See https://github.com/stephengpope/thepopebot/issues/201.`
+        );
+        resolvedModel = GEMINI_FALLBACK;
       }
       return new ChatGoogleGenerativeAI({
-        model: modelName,
+        model: resolvedModel,
         maxOutputTokens: maxTokens,
         apiKey,
       });

package/lib/ai/web-search.js

@@ -4,12 +4,14 @@
  * runs the search and the model's synthesized answer streams normally.
  */
 
+import { getConfig } from '../config.js';
+
 export function getProvider() {
-  return process.env.LLM_PROVIDER || 'anthropic';
+  return getConfig('LLM_PROVIDER');
 }
 
 export function isWebSearchAvailable() {
-  if (process.env.WEB_SEARCH === 'false') return false;
+  if (getConfig('WEB_SEARCH') === 'false') return false;
   const provider = getProvider();
   return provider === 'anthropic' || provider === 'openai';
 }

package/lib/auth/actions.js

@@ -1,6 +1,29 @@
 'use server';
 
-import { createFirstUser } from '../db/users.js';
+import { auth } from './index.js';
+import {
+  createFirstUser,
+  createUser,
+  getAllUsers,
+  deleteUser,
+  getUserByEmail,
+  updateUserEmail,
+  updateUserRole,
+  updateUserPasswordById,
+  verifyPassword,
+} from '../db/users.js';
+
+async function requireAuth() {
+  const session = await auth();
+  if (!session?.user?.id) throw new Error('Unauthorized');
+  return session.user;
+}
+
+async function requireAdmin() {
+  const user = await requireAuth();
+  if (user.role !== 'admin') throw new Error('Forbidden');
+  return user;
+}
 
 /**
  * Create the first admin user (setup action).
@@ -26,3 +49,152 @@ export async function setupAdmin(email, password) {
 
   return { success: true };
 }
+
+/**
+ * Get all users.
+ */
+export async function getUsers() {
+  await requireAdmin();
+  return getAllUsers();
+}
+
+/**
+ * Add a new user.
+ */
+export async function addUser(email, password, role) {
+  await requireAdmin();
+
+  if (!email || !password) {
+    return { error: 'Email and password are required.' };
+  }
+  if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
+    return { error: 'Invalid email format.' };
+  }
+  if (password.length < 8) {
+    return { error: 'Password must be at least 8 characters.' };
+  }
+
+  try {
+    await createUser(email, password);
+    if (role && role !== 'admin') {
+      // createUser defaults to admin; update if different role requested
+      const users = getAllUsers();
+      const created = users.find((u) => u.email === email.toLowerCase());
+      if (created) updateUserRole(created.id, role);
+    }
+    return { success: true };
+  } catch (err) {
+    if (err.message?.includes('UNIQUE constraint')) {
+      return { error: 'A user with this email already exists.' };
+    }
+    return { error: 'Failed to create user.' };
+  }
+}
+
+/**
+ * Edit a user's email and/or role.
+ */
+export async function editUser(id, { email, role }) {
+  const user = await requireAdmin();
+
+  if (role !== undefined && id === user.id) {
+    return { error: 'Cannot change your own role.' };
+  }
+
+  try {
+    if (email !== undefined) {
+      if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
+        return { error: 'Invalid email format.' };
+      }
+      updateUserEmail(id, email);
+    }
+    if (role !== undefined) {
+      updateUserRole(id, role);
+    }
+    return { success: true };
+  } catch (err) {
+    if (err.message?.includes('UNIQUE constraint')) {
+      return { error: 'A user with this email already exists.' };
+    }
+    return { error: 'Failed to update user.' };
+  }
+}
+
+/**
+ * Remove a user.
+ */
+export async function removeUser(id) {
+  const user = await requireAdmin();
+
+  if (id === user.id) {
+    return { error: 'Cannot delete yourself.' };
+  }
+
+  const deleted = deleteUser(id);
+  if (!deleted) {
+    return { error: 'User not found.' };
+  }
+  return { success: true };
+}
+
+/**
+ * Reset a user's password.
+ */
+export async function resetPassword(id, newPassword) {
+  await requireAdmin();
+
+  if (!newPassword || newPassword.length < 8) {
+    return { error: 'Password must be at least 8 characters.' };
+  }
+
+  const updated = updateUserPasswordById(id, newPassword);
+  if (!updated) {
+    return { error: 'User not found.' };
+  }
+  return { success: true };
+}
+
+/**
+ * Update the current user's own email and/or password.
+ * Requires current password for verification.
+ */
+export async function updateProfile({ email, currentPassword, newPassword }) {
+  const sessionUser = await requireAuth();
+
+  if (!currentPassword) {
+    return { error: 'Current password is required.' };
+  }
+
+  const user = getUserByEmail(sessionUser.email);
+  if (!user) {
+    return { error: 'User not found.' };
+  }
+
+  const valid = await verifyPassword(user, currentPassword);
+  if (!valid) {
+    return { error: 'Current password is incorrect.' };
+  }
+
+  try {
+    if (email !== undefined && email !== sessionUser.email) {
+      if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
+        return { error: 'Invalid email format.' };
+      }
+      updateUserEmail(user.id, email);
+    }
+
+    if (newPassword) {
+      if (newPassword.length < 8) {
+        return { error: 'New password must be at least 8 characters.' };
+      }
+      updateUserPasswordById(user.id, newPassword);
+    }
+
+    return { success: true };
+  } catch (err) {
+    if (err.message?.includes('UNIQUE constraint')) {
+      return { error: 'A user with this email already exists.' };
+    }
+    return { error: 'Failed to update profile.' };
+  }
+}

package/lib/auth/middleware.js

@@ -45,6 +45,11 @@ export const middleware = auth((req) => {
 
     return response;
   }
+
+  // Admin panel requires admin role (after auth check above)
+  if (pathname.startsWith('/admin') && req.auth?.user?.role !== 'admin') {
+    return NextResponse.redirect(new URL('/forbidden', req.url));
+  }
 });
 
 export const config = {