thepopebot 1.1.2 → 1.2.3

package/lib/paths.js

@@ -1,4 +1,4 @@
-const path = require('path');
+import path from 'path';
 
 /**
  * Central path resolver for thepopebot.
@@ -7,24 +7,30 @@ const path = require('path');
 
 const PROJECT_ROOT = process.cwd();
 
-module.exports = {
+export {
   PROJECT_ROOT,
+};
 
-  // config/ files
-  configDir: path.join(PROJECT_ROOT, 'config'),
-  cronsFile: path.join(PROJECT_ROOT, 'config', 'CRONS.json'),
-  triggersFile: path.join(PROJECT_ROOT, 'config', 'TRIGGERS.json'),
-  chatbotMd: path.join(PROJECT_ROOT, 'config', 'CHATBOT.md'),
-  jobSummaryMd: path.join(PROJECT_ROOT, 'config', 'JOB_SUMMARY.md'),
-  soulMd: path.join(PROJECT_ROOT, 'config', 'SOUL.md'),
+// config/ files
+export const configDir = path.join(PROJECT_ROOT, 'config');
+export const cronsFile = path.join(PROJECT_ROOT, 'config', 'CRONS.json');
+export const triggersFile = path.join(PROJECT_ROOT, 'config', 'TRIGGERS.json');
+export const chatbotMd = path.join(PROJECT_ROOT, 'config', 'CHATBOT.md');
+export const jobSummaryMd = path.join(PROJECT_ROOT, 'config', 'JOB_SUMMARY.md');
+export const soulMd = path.join(PROJECT_ROOT, 'config', 'SOUL.md');
 
-  // Working directories for command-type actions
-  cronDir: path.join(PROJECT_ROOT, 'cron'),
-  triggersDir: path.join(PROJECT_ROOT, 'triggers'),
+// Working directories for command-type actions
+export const cronDir = path.join(PROJECT_ROOT, 'cron');
+export const triggersDir = path.join(PROJECT_ROOT, 'triggers');
 
-  // Logs
-  logsDir: path.join(PROJECT_ROOT, 'logs'),
+// Logs
+export const logsDir = path.join(PROJECT_ROOT, 'logs');
 
-  // .env
-  envFile: path.join(PROJECT_ROOT, '.env'),
-};
+// Data (SQLite memory, etc.)
+export const dataDir = path.join(PROJECT_ROOT, 'data');
+
+// Database
+export const thepopebotDb = process.env.DATABASE_PATH || path.join(PROJECT_ROOT, 'data', 'thepopebot.sqlite');
+
+// .env
+export const envFile = path.join(PROJECT_ROOT, '.env');

package/lib/tools/create-job.js

@@ -1,5 +1,5 @@
-const { v4: uuidv4 } = require('uuid');
-const { githubApi } = require('./github');
+import { v4 as uuidv4 } from 'uuid';
+import { githubApi } from './github.js';
 
 /**
  * Create a new job branch with updated job.md
@@ -37,4 +37,4 @@ async function createJob(jobDescription) {
   return { job_id: jobId, branch };
 }
 
-module.exports = { createJob };
+export { createJob };

package/lib/tools/github.js

@@ -119,4 +119,148 @@ async function getJobStatus(jobId) {
   };
 }
 
-module.exports = { githubApi, getWorkflowRuns, getWorkflowRunJobs, getJobStatus };
+/**
+ * Get full swarm status: active + completed jobs with counts
+ * @returns {Promise<object>} - { active, completed, counts }
+ */
+async function getSwarmStatus() {
+  const [inProgress, queued, completed] = await Promise.all([
+    getWorkflowRuns('in_progress'),
+    getWorkflowRuns('queued'),
+    getWorkflowRuns('completed'),
+  ]);
+
+  const activeRuns = [
+    ...(inProgress.workflow_runs || []),
+    ...(queued.workflow_runs || []),
+  ].filter(run => run.head_branch?.startsWith('job/'));
+
+  const completedRuns = (completed.workflow_runs || [])
+    .filter(run => run.head_branch?.startsWith('job/'))
+    .slice(0, 20);
+
+  // Get step details for active jobs
+  const active = await Promise.all(
+    activeRuns.map(async (run) => {
+      const jobId = run.head_branch.slice(4);
+      const startedAt = new Date(run.created_at);
+      const durationSeconds = Math.round((Date.now() - startedAt.getTime()) / 1000);
+
+      let currentStep = null;
+      let stepsCompleted = 0;
+      let stepsTotal = 0;
+
+      try {
+        const jobsData = await getWorkflowRunJobs(run.id);
+        if (jobsData.jobs?.length > 0) {
+          const job = jobsData.jobs[0];
+          stepsTotal = job.steps?.length || 0;
+          stepsCompleted = job.steps?.filter(s => s.status === 'completed').length || 0;
+          currentStep = job.steps?.find(s => s.status === 'in_progress')?.name || null;
+        }
+      } catch (err) {
+        // Jobs endpoint may fail if run hasn't started yet
+      }
+
+      return {
+        job_id: jobId,
+        branch: run.head_branch,
+        status: run.status,
+        workflow_name: run.name,
+        started_at: run.created_at,
+        duration_seconds: durationSeconds,
+        current_step: currentStep,
+        steps_completed: stepsCompleted,
+        steps_total: stepsTotal,
+        run_id: run.id,
+        html_url: run.html_url,
+      };
+    })
+  );
+
+  // Completed jobs are lighter — no step detail needed
+  const completedJobs = completedRuns.map((run) => ({
+    job_id: run.head_branch.slice(4),
+    branch: run.head_branch,
+    status: run.status,
+    conclusion: run.conclusion,
+    workflow_name: run.name,
+    started_at: run.created_at,
+    updated_at: run.updated_at,
+    run_id: run.id,
+    html_url: run.html_url,
+  }));
+
+  const successCount = completedJobs.filter(j => j.conclusion === 'success').length;
+  const failedCount = completedJobs.length - successCount;
+
+  return {
+    active,
+    completed: completedJobs,
+    counts: {
+      running: active.filter(j => j.status === 'in_progress').length,
+      queued: active.filter(j => j.status === 'queued').length,
+      succeeded: successCount,
+      failed: failedCount,
+    },
+  };
+}
+
+/**
+ * Cancel a workflow run
+ * @param {number} runId - Workflow run ID
+ */
+async function cancelWorkflowRun(runId) {
+  const { GH_OWNER, GH_REPO } = process.env;
+  const res = await fetch(
+    `https://api.github.com/repos/${GH_OWNER}/${GH_REPO}/actions/runs/${runId}/cancel`,
+    {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${process.env.GH_TOKEN}`,
+        'Accept': 'application/vnd.github+json',
+        'X-GitHub-Api-Version': '2022-11-28',
+      },
+    }
+  );
+  if (!res.ok && res.status !== 202) {
+    const error = await res.text();
+    throw new Error(`GitHub API error: ${res.status} ${error}`);
+  }
+  return { success: true };
+}
+
+/**
+ * Re-run a workflow run (all jobs or failed only)
+ * @param {number} runId - Workflow run ID
+ * @param {boolean} [failedOnly=false] - Only rerun failed jobs
+ */
+async function rerunWorkflowRun(runId, failedOnly = false) {
+  const { GH_OWNER, GH_REPO } = process.env;
+  const endpoint = failedOnly
+    ? `https://api.github.com/repos/${GH_OWNER}/${GH_REPO}/actions/runs/${runId}/rerun-failed-jobs`
+    : `https://api.github.com/repos/${GH_OWNER}/${GH_REPO}/actions/runs/${runId}/rerun`;
+  const res = await fetch(endpoint, {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${process.env.GH_TOKEN}`,
+      'Accept': 'application/vnd.github+json',
+      'X-GitHub-Api-Version': '2022-11-28',
+    },
+  });
+  if (!res.ok && res.status !== 201) {
+    const error = await res.text();
+    throw new Error(`GitHub API error: ${res.status} ${error}`);
+  }
+  return { success: true };
+}
+
+export {
+  githubApi,
+  getWorkflowRuns,
+  getWorkflowRunJobs,
+  getJobStatus,
+  getSwarmStatus,
+  cancelWorkflowRun,
+  rerunWorkflowRun,
+};

package/lib/tools/openai.js

@@ -32,4 +32,4 @@ async function transcribeAudio(audioBuffer, filename) {
   return result.text;
 }
 
-module.exports = { isWhisperEnabled, transcribeAudio };
+export { isWhisperEnabled, transcribeAudio };

package/lib/tools/telegram.js

@@ -1,5 +1,6 @@
-const { Bot } = require('grammy');
-const { hydrateReply } = require('@grammyjs/parse-mode');
+import { Bot } from 'grammy';
+import parseModePlugin from '@grammyjs/parse-mode';
+const { hydrateReply } = parseModePlugin;
 
 const MAX_LENGTH = 4096;
 
@@ -277,7 +278,7 @@ function startTypingIndicator(botToken, chatId) {
   };
 }
 
-module.exports = {
+export {
   getBot,
   setWebhook,
   sendMessage,

package/lib/triggers.js

@@ -1,7 +1,6 @@
-const fs = require('fs');
-const paths = require('./paths');
-
-const { executeAction } = require('./actions');
+import fs from 'fs';
+import { triggersFile, triggersDir } from './paths.js';
+import { executeAction } from './actions.js';
 
 /**
  * Replace {{body.field}} templates with values from request context
@@ -30,7 +29,7 @@ async function executeActions(trigger, context) {
       const resolved = { ...action };
       if (resolved.command) resolved.command = resolveTemplate(resolved.command, context);
       if (resolved.job) resolved.job = resolveTemplate(resolved.job, context);
-      const result = await executeAction(resolved, { cwd: paths.triggersDir, data: context.body });
+      const result = await executeAction(resolved, { cwd: triggersDir, data: context.body });
       console.log(`[TRIGGER] ${trigger.name}: ${result || 'ran'}`);
     } catch (err) {
       console.error(`[TRIGGER] ${trigger.name}: error - ${err.message}`);
@@ -43,7 +42,7 @@ async function executeActions(trigger, context) {
  * @returns {{ triggerMap: Map, fireTriggers: Function }}
  */
 function loadTriggers() {
-  const triggerFile = paths.triggersFile;
+  const triggerFile = triggersFile;
   const triggerMap = new Map();
 
   console.log('\n--- Triggers ---');
@@ -102,4 +101,4 @@ function loadTriggers() {
   return { triggerMap, fireTriggers };
 }
 
-module.exports = { loadTriggers };
+export { loadTriggers };

package/lib/utils/render-md.js

@@ -1,6 +1,6 @@
-const fs = require('fs');
-const path = require('path');
-const paths = require('../paths');
+import fs from 'fs';
+import path from 'path';
+import { PROJECT_ROOT } from '../paths.js';
 
 const INCLUDE_PATTERN = /\{\{([^}]+\.md)\}\}/g;
 
@@ -15,7 +15,7 @@ function render_md(filePath, chain = []) {
   const resolved = path.resolve(filePath);
 
   if (chain.includes(resolved)) {
-    const cycle = [...chain, resolved].map((p) => path.relative(paths.PROJECT_ROOT, p)).join(' -> ');
+    const cycle = [...chain, resolved].map((p) => path.relative(PROJECT_ROOT, p)).join(' -> ');
     console.log(`[render_md] Circular include detected: ${cycle}`);
     return '';
   }
@@ -28,7 +28,7 @@ function render_md(filePath, chain = []) {
   const currentChain = [...chain, resolved];
 
   return content.replace(INCLUDE_PATTERN, (match, includePath) => {
-    const includeResolved = path.resolve(paths.PROJECT_ROOT, includePath.trim());
+    const includeResolved = path.resolve(PROJECT_ROOT, includePath.trim());
     if (!fs.existsSync(includeResolved)) {
       return match;
     }
@@ -36,4 +36,4 @@ function render_md(filePath, chain = []) {
   });
 }
 
-module.exports = { render_md };
+export { render_md };

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "thepopebot",
-  "version": "1.1.2",
+  "version": "1.2.3",
+  "type": "module",
   "description": "Create autonomous AI agents with a two-layer architecture: Next.js Event Handler + Docker Agent.",
   "bin": {
     "thepopebot": "./bin/cli.js"
@@ -9,7 +10,14 @@
   "exports": {
     "./api": "./api/index.js",
     "./config": "./config/index.js",
-    "./instrumentation": "./config/instrumentation.js"
+    "./instrumentation": "./config/instrumentation.js",
+    "./auth": "./lib/auth/index.js",
+    "./auth/actions": "./lib/auth/actions.js",
+    "./chat/api": "./lib/chat/api.js",
+    "./db": "./lib/db/index.js",
+    "./chat": "./lib/chat/components/index.js",
+    "./chat/actions": "./lib/chat/actions.js",
+    "./middleware": "./lib/auth/middleware.js"
   },
   "files": [
     "bin/",
@@ -20,6 +28,9 @@
     "templates/"
   ],
   "scripts": {
+    "build": "esbuild lib/chat/components/*.jsx lib/chat/components/**/*.jsx --outdir=lib/chat/components --format=esm --jsx=automatic --outbase=lib/chat/components",
+    "prepublishOnly": "npm run build",
+    "local": "bash bin/local.sh",
     "postinstall": "node bin/postinstall.js",
     "test": "echo \"No tests yet\" && exit 0"
   },
@@ -35,21 +46,47 @@
   "author": "Stephen Pope",
   "license": "MIT",
   "dependencies": {
+    "@ai-sdk/react": "^2.0.0",
     "@grammyjs/parse-mode": "^2.2.0",
+    "@langchain/anthropic": "^1.3.17",
+    "@langchain/core": "^1.1.24",
+    "@langchain/google-genai": "^2.1.18",
+    "@langchain/langgraph": "^1.1.4",
+    "@langchain/langgraph-checkpoint-sqlite": "^1.0.1",
+    "@langchain/openai": "^1.2.7",
+    "ai": "^5.0.0",
+    "bcrypt-ts": "^6.0.0",
+    "better-sqlite3": "^12.6.2",
+    "chalk": "^5.3.0",
+    "class-variance-authority": "^0.7.0",
+    "clsx": "^2.0.0",
     "dotenv": "^16.3.1",
+    "drizzle-orm": "^0.44.0",
     "grammy": "^1.39.3",
-    "node-cron": "^3.0.3",
-    "uuid": "^9.0.0",
-    "chalk": "^5.3.0",
     "inquirer": "^9.2.12",
+    "lucide-react": "^0.400.0",
+    "node-cron": "^3.0.3",
     "open": "^10.0.0",
-    "ora": "^8.0.1"
+    "ora": "^8.0.1",
+    "streamdown": "^2.2.0",
+    "tailwind-merge": "^3.0.0",
+    "uuid": "^9.0.0",
+    "zod": "^4.3.6"
   },
   "peerDependencies": {
     "next": ">=15.0.0",
+    "next-auth": "^5.0.0-beta.30",
     "react": ">=19.0.0",
     "react-dom": ">=19.0.0"
   },
+  "peerDependenciesMeta": {
+    "next-auth": {
+      "optional": false
+    }
+  },
+  "devDependencies": {
+    "esbuild": "^0.27.3"
+  },
   "engines": {
     "node": ">=18.0.0"
   }

package/setup/lib/auth.mjs

@@ -1,5 +1,6 @@
 import { writeFileSync, readFileSync, existsSync, mkdirSync } from 'fs';
 import { join } from 'path';
+import { randomBytes } from 'crypto';
 
 const ROOT_DIR = process.cwd();
 
@@ -98,24 +99,36 @@ export function writeModelsJson(providerName, { baseUrl, apiKey, api, models })
  */
 export function writeEnvFile(config) {
   const {
-    apiKey,
     githubToken,
     githubOwner,
     githubRepo,
     telegramBotToken,
     telegramWebhookSecret,
     ghWebhookSecret,
-    anthropicApiKey,
+    llmProvider,
+    llmModel,
+    providerEnvKey,
+    providerApiKey,
     openaiApiKey,
     telegramChatId,
     telegramVerification,
   } = config;
 
+  // Build the provider API key line(s)
+  // Always write the provider's key; also write OPENAI_API_KEY if it's a separate key (for Whisper)
+  let apiKeyLines = `# LLM API key (${providerEnvKey})\n${providerEnvKey}=${providerApiKey}`;
+  if (providerEnvKey !== 'OPENAI_API_KEY') {
+    apiKeyLines += `\n\n# OpenAI API key for Whisper voice transcription (optional)\nOPENAI_API_KEY=${openaiApiKey || ''}`;
+  }
+
+  // Generate AUTH_SECRET (32 random bytes, base64 encoded)
+  const authSecret = randomBytes(32).toString('base64');
+
   const envContent = `# thepopebot Configuration
 # Generated by setup wizard
 
-# Authentication key for /api/webhook endpoint
-API_KEY=${apiKey}
+# Auth.js secret (used for session encryption)
+AUTH_SECRET=${authSecret}
 
 # GitHub Personal Access Token (fine-grained: Actions, Contents, Metadata, Pull requests)
 GH_TOKEN=${githubToken}
@@ -124,6 +137,10 @@ GH_TOKEN=${githubToken}
 GH_OWNER=${githubOwner}
 GH_REPO=${githubRepo}
 
+# LLM provider and model (used by both Event Handler and Docker Agent)
+LLM_PROVIDER=${llmProvider}
+LLM_MODEL=${llmModel}
+
 # Telegram bot token from @BotFather
 TELEGRAM_BOT_TOKEN=${telegramBotToken || ''}
 
@@ -139,11 +156,7 @@ TELEGRAM_VERIFICATION=${telegramVerification || ''}
 # Secret for GitHub Actions webhook auth (must match GH_WEBHOOK_SECRET secret)
 GH_WEBHOOK_SECRET=${ghWebhookSecret}
 
-# Anthropic API key for Claude chat features
-ANTHROPIC_API_KEY=${anthropicApiKey}
-
-# OpenAI API key for Whisper voice transcription (optional)
-OPENAI_API_KEY=${openaiApiKey || ''}
+${apiKeyLines}
 `;
 
   const envPath = join(ROOT_DIR, '.env');

package/setup/lib/prerequisites.mjs

@@ -48,11 +48,11 @@ function getGitRemoteInfo() {
     // Handle both HTTPS and SSH formats
     // https://github.com/owner/repo.git
     // git@github.com:owner/repo.git
-    const httpsMatch = remote.match(/github\.com\/([^/]+)\/([^/.]+)/);
-    const sshMatch = remote.match(/github\.com:([^/]+)\/([^/.]+)/);
+    const httpsMatch = remote.match(/github\.com\/([^/]+)\/(.+?)(?:\.git)?$/);
+    const sshMatch = remote.match(/github\.com:([^/]+)\/(.+?)(?:\.git)?$/);
     const match = httpsMatch || sshMatch;
     if (match) {
-      return { owner: match[1], repo: match[2].replace('.git', '') };
+      return { owner: match[1], repo: match[2] };
     }
     return null;
   } catch {
@@ -109,6 +109,13 @@ export async function checkPrerequisites() {
   // Check git
   results.git.installed = commandExists('git');
   if (results.git.installed) {
+    // Initialize git repo if needed (must happen before remote check)
+    try {
+      execSync('git rev-parse --git-dir', { stdio: 'ignore' });
+      results.git.initialized = true;
+    } catch {
+      results.git.initialized = false;
+    }
     results.git.remoteInfo = getGitRemoteInfo();
   }
 

package/setup/lib/telegram-verify.mjs

@@ -37,31 +37,18 @@ export async function runVerificationFlow(verificationCode, { allowSkip = false
 /**
  * Wait for server to pick up .env changes and verify it's running
  * @param {string} ngrokUrl - The ngrok URL
- * @param {string} apiKey - The API key for authentication
  * @returns {Promise<boolean>} - True if verified successfully
  */
-export async function verifyRestart(ngrokUrl, apiKey) {
+export async function verifyRestart(ngrokUrl) {
   console.log(chalk.dim('\n  Waiting for server to pick up changes...\n'));
   await new Promise(resolve => setTimeout(resolve, 3000));
 
-  // Verify server is up
+  // Verify server is up (any HTTP response means it's running)
   try {
-    const response = await fetch(`${ngrokUrl}/api/ping`, {
+    await fetch(`${ngrokUrl}/api/ping`, {
       method: 'GET',
-      headers: { 'x-api-key': apiKey },
       signal: AbortSignal.timeout(10000)
     });
-
-    if (!response.ok) {
-      console.log(chalk.red('  ✗ Could not reach server.\n'));
-      return false;
-    }
-
-    const data = await response.json();
-    if (data.message !== 'Pong!') {
-      console.log(chalk.red('  ✗ Unexpected server response.\n'));
-      return false;
-    }
   } catch (err) {
     console.log(chalk.red(`  ✗ Server not reachable: ${err.message}\n`));
     return false;

package/setup/setup-telegram.mjs

@@ -48,7 +48,7 @@ function loadEnvFile() {
 
 async function main() {
   console.log(chalk.bold.cyan('\n  Telegram Webhook Setup\n'));
-  console.log(chalk.dim('  Use this to reconfigure Telegram after restarting ngrok.\n'));
+  console.log(chalk.dim('  Use this to reconfigure the Telegram webhook.\n'));
 
   // Check prerequisites
   const prereqs = await checkPrerequisites();
@@ -64,81 +64,50 @@ async function main() {
   // Load existing config
   const env = loadEnvFile();
 
-  // Get ngrok URL first (verify server is up)
-  console.log(chalk.yellow('\n  Make sure your server is running:\n'));
-  console.log(chalk.dim('  Terminal 1: ') + chalk.cyan('npm run dev'));
-  console.log(chalk.dim('  Terminal 2: ') + chalk.cyan('ngrok http 3000\n'));
+  // Get APP_URL (verify server is up)
+  console.log(chalk.yellow('\n  Make sure your server is running and publicly accessible.\n'));
 
-  let ngrokUrl = null;
-  while (!ngrokUrl) {
+  let appUrl = null;
+
+  // Try to read APP_URL from .env first
+  const existingAppUrl = env?.APP_URL;
+  if (existingAppUrl) {
+    printInfo(`Found APP_URL in .env: ${existingAppUrl}`);
+    const useExisting = await confirm('Use this URL?');
+    if (useExisting) {
+      appUrl = existingAppUrl;
+    }
+  }
+
+  while (!appUrl) {
     const { url } = await inquirer.prompt([
       {
         type: 'input',
         name: 'url',
-        message: 'Paste your ngrok URL (https://...ngrok...):',
+        message: 'Enter your APP_URL (https://...):',
         validate: (input) => {
           if (!input) return 'URL is required';
           if (!input.startsWith('https://')) return 'URL must start with https://';
-          if (!input.includes('ngrok')) return 'URL should be an ngrok URL';
           return true;
         },
       },
     ]);
-    const testUrl = url.replace(/\/$/, '');
-
-    // Verify the server is reachable through ngrok
-    const healthSpinner = ora('Verifying server is reachable...').start();
-    const apiKey = env?.API_KEY;
-    try {
-      const response = await fetch(`${testUrl}/api/ping`, {
-        method: 'GET',
-        headers: apiKey ? { 'x-api-key': apiKey } : {},
-        signal: AbortSignal.timeout(10000)
-      });
-      if (response.ok) {
-        const data = await response.json();
-        if (data.message === 'Pong!') {
-          healthSpinner.succeed('Server is reachable and authenticated');
-          ngrokUrl = testUrl;
-        } else {
-          healthSpinner.fail('Unexpected response from server');
-          const retry = await confirm('Try again?');
-          if (!retry) {
-            ngrokUrl = testUrl;
-          }
-        }
-      } else if (response.status === 401) {
-        healthSpinner.fail('Server responded but API key mismatch');
-        printWarning('Check that API_KEY in .env matches the running server');
-        const retry = await confirm('Try again?');
-        if (!retry) {
-          ngrokUrl = testUrl;
-        }
-      } else {
-        healthSpinner.fail(`Server returned status ${response.status}`);
-        printWarning('Make sure the server is running (npm run dev)');
-        const retry = await confirm('Try again?');
-        if (!retry) {
-          ngrokUrl = testUrl;
-        }
-      }
-    } catch (error) {
-      healthSpinner.fail(`Could not reach server: ${error.message}`);
-      printWarning('Make sure both the server AND ngrok are running');
-      const retry = await confirm('Try again?');
-      if (!retry) {
-        ngrokUrl = testUrl;
-      }
-    }
+    appUrl = url.replace(/\/$/, '');
   }
 
-  // Set GH_WEBHOOK_URL variable
-  const urlSpinner = ora('Updating GH_WEBHOOK_URL variable...').start();
-  const urlResult = await setVariables(owner, repo, { GH_WEBHOOK_URL: ngrokUrl });
-  if (urlResult.GH_WEBHOOK_URL.success) {
-    urlSpinner.succeed('GH_WEBHOOK_URL variable updated');
+  // Update APP_URL and APP_HOSTNAME in .env
+  const appHostname = new URL(appUrl).hostname;
+  updateEnvVariable('APP_URL', appUrl);
+  updateEnvVariable('APP_HOSTNAME', appHostname);
+  printSuccess('APP_URL saved to .env');
+
+  // Set APP_URL variable on GitHub
+  const urlSpinner = ora('Updating APP_URL variable...').start();
+  const urlResult = await setVariables(owner, repo, { APP_URL: appUrl });
+  if (urlResult.APP_URL.success) {
+    urlSpinner.succeed('APP_URL variable updated');
   } else {
-    urlSpinner.fail(`Failed: ${urlResult.GH_WEBHOOK_URL.error}`);
+    urlSpinner.fail(`Failed: ${urlResult.APP_URL.error}`);
   }
 
   // Get Telegram token - try .env first
@@ -193,7 +162,7 @@ async function main() {
   }
 
   // Register Telegram webhook
-  const webhookUrl = `${ngrokUrl}/api/telegram/webhook`;
+  const webhookUrl = `${appUrl}/api/telegram/webhook`;
   const tgSpinner = ora('Registering Telegram webhook...').start();
   const tgResult = await setTelegramWebhook(token, webhookUrl, webhookSecret);
   if (tgResult.ok) {