thepopebot 1.0.0

package/bin/cli.js

@@ -0,0 +1,278 @@
+#!/usr/bin/env node
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const command = process.argv[2];
+const args = process.argv.slice(3);
+
+function printUsage() {
+  console.log(`
+Usage: thepopebot <command>
+
+Commands:
+  init               Scaffold a new thepopebot project
+  setup              Run interactive setup wizard
+  setup-telegram     Reconfigure Telegram webhook
+  reset [file]       Restore a template file (or list available templates)
+`);
+}
+
+/**
+ * Collect all template files as relative paths.
+ */
+function getTemplateFiles(templatesDir) {
+  const files = [];
+  function walk(dir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath);
+      } else {
+        files.push(path.relative(templatesDir, fullPath));
+      }
+    }
+  }
+  walk(templatesDir);
+  return files;
+}
+
+function init() {
+  const cwd = process.cwd();
+  const packageDir = path.join(__dirname, '..');
+  const templatesDir = path.join(packageDir, 'templates');
+
+  console.log('\nScaffolding thepopebot project...\n');
+
+  const templateFiles = getTemplateFiles(templatesDir);
+  const created = [];
+  const skipped = [];
+  const changed = [];
+
+  for (const relPath of templateFiles) {
+    const src = path.join(templatesDir, relPath);
+    const dest = path.join(cwd, relPath);
+
+    if (!fs.existsSync(dest)) {
+      // File doesn't exist — create it
+      fs.mkdirSync(path.dirname(dest), { recursive: true });
+      fs.copyFileSync(src, dest);
+      created.push(relPath);
+      console.log(`  Created ${relPath}`);
+    } else {
+      // File exists — check if template has changed
+      const srcContent = fs.readFileSync(src);
+      const destContent = fs.readFileSync(dest);
+      if (srcContent.equals(destContent)) {
+        skipped.push(relPath);
+      } else {
+        changed.push(relPath);
+        console.log(`  Skipped ${relPath} (already exists)`);
+      }
+    }
+  }
+
+  // Create package.json if it doesn't exist
+  const pkgPath = path.join(cwd, 'package.json');
+  if (!fs.existsSync(pkgPath)) {
+    const dirName = path.basename(cwd);
+    const pkg = {
+      name: dirName,
+      private: true,
+      scripts: {
+        dev: 'next dev',
+        build: 'next build',
+        start: 'next start',
+        setup: 'thepopebot setup',
+        'setup-telegram': 'thepopebot setup-telegram',
+      },
+      dependencies: {
+        thepopebot: '^1.0.0',
+        next: '^16.0.0',
+        react: '^19.0.0',
+        'react-dom': '^19.0.0',
+      },
+    };
+    fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+    console.log('  Created package.json');
+  } else {
+    console.log('  Skipped package.json (already exists)');
+  }
+
+  // Create .gitkeep files for empty dirs
+  const gitkeepDirs = ['cron', 'triggers', 'logs'];
+  for (const dir of gitkeepDirs) {
+    const gitkeep = path.join(cwd, dir, '.gitkeep');
+    if (!fs.existsSync(gitkeep)) {
+      fs.mkdirSync(path.join(cwd, dir), { recursive: true });
+      fs.writeFileSync(gitkeep, '');
+    }
+  }
+
+  // Report changed templates
+  if (changed.length > 0) {
+    console.log('\n  Updated templates available:');
+    console.log('  These files differ from the current package templates.');
+    console.log('  This may be from your edits, or from a thepopebot update.\n');
+    for (const file of changed) {
+      console.log(`    ${file}`);
+    }
+    console.log('\n  To view differences:  npx thepopebot diff <file>');
+    console.log('  To reset to default:  npx thepopebot reset <file>');
+  }
+
+  if (created.length > 0 || !fs.existsSync(path.join(cwd, 'node_modules'))) {
+    console.log('\nDone! Next steps:\n');
+    console.log('  1. npm install');
+    console.log('  2. npm run setup');
+    console.log('  3. npm run dev\n');
+  } else {
+    console.log('\nDone!\n');
+  }
+}
+
+/**
+ * List all available template files, or restore a specific one.
+ */
+function reset(filePath) {
+  const packageDir = path.join(__dirname, '..');
+  const templatesDir = path.join(packageDir, 'templates');
+  const cwd = process.cwd();
+
+  if (!filePath) {
+    console.log('\nAvailable template files:\n');
+    const files = getTemplateFiles(templatesDir);
+    for (const file of files) {
+      console.log(`  ${file}`);
+    }
+    console.log('\nUsage: thepopebot reset <file>');
+    console.log('Example: thepopebot reset operating_system/SOUL.md\n');
+    return;
+  }
+
+  const src = path.join(templatesDir, filePath);
+  const dest = path.join(cwd, filePath);
+
+  if (!fs.existsSync(src)) {
+    console.error(`\nTemplate not found: ${filePath}`);
+    console.log('Run "thepopebot reset" to see available templates.\n');
+    process.exit(1);
+  }
+
+  if (fs.statSync(src).isDirectory()) {
+    console.log(`\nRestoring ${filePath}/...\n`);
+    copyDirSyncForce(src, dest);
+  } else {
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.copyFileSync(src, dest);
+    console.log(`\nRestored ${filePath}\n`);
+  }
+}
+
+/**
+ * Show the diff between a user's file and the package template.
+ */
+function diff(filePath) {
+  const packageDir = path.join(__dirname, '..');
+  const templatesDir = path.join(packageDir, 'templates');
+  const cwd = process.cwd();
+
+  if (!filePath) {
+    // Show all files that differ
+    console.log('\nFiles that differ from package templates:\n');
+    const files = getTemplateFiles(templatesDir);
+    let anyDiff = false;
+    for (const file of files) {
+      const src = path.join(templatesDir, file);
+      const dest = path.join(cwd, file);
+      if (fs.existsSync(dest)) {
+        const srcContent = fs.readFileSync(src);
+        const destContent = fs.readFileSync(dest);
+        if (!srcContent.equals(destContent)) {
+          console.log(`  ${file}`);
+          anyDiff = true;
+        }
+      } else {
+        console.log(`  ${file} (missing)`);
+        anyDiff = true;
+      }
+    }
+    if (!anyDiff) {
+      console.log('  All files match package templates.');
+    }
+    console.log('\nUsage: thepopebot diff <file>');
+    console.log('Example: thepopebot diff operating_system/SOUL.md\n');
+    return;
+  }
+
+  const src = path.join(templatesDir, filePath);
+  const dest = path.join(cwd, filePath);
+
+  if (!fs.existsSync(src)) {
+    console.error(`\nTemplate not found: ${filePath}`);
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(dest)) {
+    console.log(`\n${filePath} does not exist in your project.`);
+    console.log(`Run "thepopebot reset ${filePath}" to create it.\n`);
+    return;
+  }
+
+  try {
+    // Use git diff for nice colored output, fall back to plain diff
+    execSync(`git diff --no-index -- "${dest}" "${src}"`, { stdio: 'inherit' });
+    console.log('\nFiles are identical.\n');
+  } catch (e) {
+    // git diff exits with 1 when files differ (output already printed)
+    console.log(`\n  To reset: thepopebot reset ${filePath}\n`);
+  }
+}
+
+function copyDirSyncForce(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirSyncForce(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+      console.log(`  Restored ${path.relative(process.cwd(), destPath)}`);
+    }
+  }
+}
+
+function setup() {
+  const setupScript = path.join(__dirname, '..', 'setup', 'setup.mjs');
+  execSync(`node ${setupScript}`, { stdio: 'inherit', cwd: process.cwd() });
+}
+
+function setupTelegram() {
+  const setupScript = path.join(__dirname, '..', 'setup', 'setup-telegram.mjs');
+  execSync(`node ${setupScript}`, { stdio: 'inherit', cwd: process.cwd() });
+}
+
+switch (command) {
+  case 'init':
+    init();
+    break;
+  case 'setup':
+    setup();
+    break;
+  case 'setup-telegram':
+    setupTelegram();
+    break;
+  case 'reset':
+    reset(args[0]);
+    break;
+  case 'diff':
+    diff(args[0]);
+    break;
+  default:
+    printUsage();
+    process.exit(command ? 1 : 0);
+}

package/config/index.js

@@ -0,0 +1,29 @@
+const path = require('path');
+
+/**
+ * Next.js config wrapper for thepopebot.
+ * Enables instrumentation hook for cron scheduling on server start.
+ *
+ * Usage in user's next.config.mjs:
+ *   import { withThepopebot } from 'thepopebot/config';
+ *   export default withThepopebot({});
+ *
+ * @param {Object} nextConfig - User's Next.js config
+ * @returns {Object} Enhanced Next.js config
+ */
+function withThepopebot(nextConfig = {}) {
+  return {
+    ...nextConfig,
+    // Ensure server-only packages aren't bundled for client
+    serverExternalPackages: [
+      ...(nextConfig.serverExternalPackages || []),
+      'thepopebot',
+      'grammy',
+      '@grammyjs/parse-mode',
+      'node-cron',
+      'uuid',
+    ],
+  };
+}
+
+module.exports = { withThepopebot };

package/config/instrumentation.js

@@ -0,0 +1,29 @@
+/**
+ * Next.js instrumentation hook for thepopebot.
+ * This file is loaded by Next.js on server start when instrumentationHook is enabled.
+ *
+ * Users should create an instrumentation.js in their project root that imports this:
+ *
+ *   export { register } from 'thepopebot/instrumentation';
+ *
+ * Or they can re-export and add their own logic.
+ */
+
+let initialized = false;
+
+async function register() {
+  // Only run on the server, and only once
+  if (typeof window !== 'undefined' || initialized) return;
+  initialized = true;
+
+  // Load .env from project root
+  require('dotenv').config();
+
+  // Start cron scheduler
+  const { loadCrons } = require('../lib/cron');
+  loadCrons();
+
+  console.log('thepopebot initialized');
+}
+
+module.exports = { register };

package/docker/Dockerfile

@@ -0,0 +1,51 @@
+FROM node:22-bookworm-slim
+
+RUN apt-get update && apt-get install -y \
+    git \
+    jq \
+    curl \
+    procps \
+    # Chrome/Chromium dependencies
+    libnss3 \
+    libnspr4 \
+    libatk1.0-0 \
+    libatk-bridge2.0-0 \
+    libcups2 \
+    libdrm2 \
+    libdbus-1-3 \
+    libxkbcommon0 \
+    libatspi2.0-0 \
+    libxcomposite1 \
+    libxdamage1 \
+    libxfixes3 \
+    libxrandr2 \
+    libgbm1 \
+    libasound2 \
+    libpango-1.0-0 \
+    libcairo2 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install GitHub CLI
+RUN curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg \
+    && echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | tee /etc/apt/sources.list.d/github-cli.list > /dev/null \
+    && apt-get update && apt-get install -y gh \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN npm install -g @mariozechner/pi-coding-agent
+
+# Create Pi config directory (extension loaded from repo at runtime)
+RUN mkdir -p /root/.pi/agent
+
+# Clone pi-skills and install browser-tools (includes Puppeteer + Chromium)
+RUN git clone https://github.com/badlogic/pi-skills.git /pi-skills
+WORKDIR /pi-skills/browser-tools
+RUN npm install
+WORKDIR /pi-skills/brave-search
+RUN npm install
+
+COPY entrypoint.sh /entrypoint.sh
+RUN chmod +x /entrypoint.sh
+
+WORKDIR /job
+
+ENTRYPOINT ["/entrypoint.sh"]

package/docker/entrypoint.sh

@@ -0,0 +1,100 @@
+#!/bin/bash
+set -e
+
+# Extract job ID from branch name (job/uuid -> uuid), fallback to random UUID
+if [[ "$BRANCH" == job/* ]]; then
+    JOB_ID="${BRANCH#job/}"
+else
+    JOB_ID=$(cat /proc/sys/kernel/random/uuid)
+fi
+echo "Job ID: ${JOB_ID}"
+
+# Start Chrome (using Puppeteer's chromium from pi-skills browser-tools)
+CHROME_BIN=$(find /root/.cache/puppeteer -name "chrome" -type f | head -1)
+$CHROME_BIN --headless --no-sandbox --disable-gpu --remote-debugging-port=9222 2>/dev/null &
+CHROME_PID=$!
+sleep 2
+
+# Export SECRETS (base64 JSON) as flat env vars (GH_TOKEN, ANTHROPIC_API_KEY, etc.)
+# These are filtered from LLM's bash subprocess by env-sanitizer extension
+if [ -n "$SECRETS" ]; then
+    SECRETS_JSON=$(echo "$SECRETS" | base64 -d)
+    eval $(echo "$SECRETS_JSON" | jq -r 'to_entries | .[] | "export \(.key)=\"\(.value)\""')
+    export SECRETS="$SECRETS_JSON"  # Keep decoded for extension to parse
+fi
+
+# Export LLM_SECRETS (base64 JSON) as flat env vars
+# These are NOT filtered - LLM can access these (browser logins, skill API keys, etc.)
+if [ -n "$LLM_SECRETS" ]; then
+    LLM_SECRETS_JSON=$(echo "$LLM_SECRETS" | base64 -d)
+    eval $(echo "$LLM_SECRETS_JSON" | jq -r 'to_entries | .[] | "export \(.key)=\"\(.value)\""')
+fi
+
+# Git setup - derive identity from GitHub token
+gh auth setup-git
+GH_USER_JSON=$(gh api user -q '{name: .name, login: .login, email: .email, id: .id}')
+GH_USER_NAME=$(echo "$GH_USER_JSON" | jq -r '.name // .login')
+GH_USER_EMAIL=$(echo "$GH_USER_JSON" | jq -r '.email // "\(.id)+\(.login)@users.noreply.github.com"')
+git config --global user.name "$GH_USER_NAME"
+git config --global user.email "$GH_USER_EMAIL"
+
+# Clone branch
+if [ -n "$REPO_URL" ]; then
+    git clone --single-branch --branch "$BRANCH" --depth 1 "$REPO_URL" /job
+else
+    echo "No REPO_URL provided"
+fi
+
+cd /job
+
+# Create temp directory for agent use (gitignored via tmp/)
+mkdir -p /job/tmp
+
+# Symlink pi-skills into .pi/skills/ so Pi discovers them
+ln -sf /pi-skills/brave-search /job/.pi/skills/brave-search
+
+# Setup logs
+LOG_DIR="/job/logs/${JOB_ID}"
+mkdir -p "${LOG_DIR}"
+
+# 1. Build system prompt from operating_system MD files
+SYSTEM_FILES=("SOUL.md" "AGENT.md")
+> /job/.pi/SYSTEM.md
+for i in "${!SYSTEM_FILES[@]}"; do
+    cat "/job/operating_system/${SYSTEM_FILES[$i]}" >> /job/.pi/SYSTEM.md
+    if [ "$i" -lt $((${#SYSTEM_FILES[@]} - 1)) ]; then
+        echo -e "\n\n" >> /job/.pi/SYSTEM.md
+    fi
+done
+
+PROMPT="
+
+# Your Job
+
+$(cat /job/logs/${JOB_ID}/job.md)"
+
+MODEL_FLAGS=""
+if [ -n "$MODEL" ]; then
+    MODEL_FLAGS="--provider anthropic --model $MODEL"
+fi
+
+pi $MODEL_FLAGS -p "$PROMPT" --session-dir "${LOG_DIR}"
+
+# 2. Commit changes + logs
+git add -A
+git add -f "${LOG_DIR}"
+git commit -m "thepopebot: job ${JOB_ID}" || true
+git push origin
+
+# 3. Merge (pi has memory of job via session)
+#if [ -n "$REPO_URL" ] && [ -f "/job/MERGE_JOB.md" ]; then
+#    echo "MERGED"
+#    pi -p "$(cat /job/MERGE_JOB.md)" --session-dir "${LOG_DIR}" --continue
+#fi
+
+# 5. Create PR (auto-merge handled by GitHub Actions workflow)
+gh pr create --title "thepopebot: job ${JOB_ID}" --body "Automated job" --base main || true
+
+# Cleanup
+kill $CHROME_PID 2>/dev/null || true
+echo "Done. Job ID: ${JOB_ID}"

package/lib/actions.js

@@ -0,0 +1,40 @@
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const execAsync = promisify(exec);
+const { createJob } = require('./tools/create-job');
+
+/**
+ * Execute a single action
+ * @param {Object} action - { type, job, command, url, method, headers, vars }
+ * @param {Object} opts - { cwd, data }
+ * @returns {Promise<string>} Result description for logging
+ */
+async function executeAction(action, opts = {}) {
+  const type = action.type || 'agent';
+
+  if (type === 'command') {
+    const { stdout, stderr } = await execAsync(action.command, { cwd: opts.cwd });
+    return (stdout || stderr || '').trim();
+  }
+
+  if (type === 'http') {
+    const method = (action.method || 'POST').toUpperCase();
+    const headers = { 'Content-Type': 'application/json', ...action.headers };
+    const fetchOpts = { method, headers };
+
+    if (method !== 'GET') {
+      const body = { ...action.vars };
+      if (opts.data) body.data = opts.data;
+      fetchOpts.body = JSON.stringify(body);
+    }
+
+    const res = await fetch(action.url, fetchOpts);
+    return `${method} ${action.url} → ${res.status}`;
+  }
+
+  // Default: agent
+  const result = await createJob(action.job);
+  return `job ${result.job_id}`;
+}
+
+module.exports = { executeAction };

package/lib/claude/conversation.js

@@ -0,0 +1,76 @@
+/**
+ * In-memory conversation history management per Telegram chat.
+ * - Keyed by chat_id
+ * - 30-minute TTL per conversation
+ * - Max 20 messages per conversation
+ */
+
+const MAX_MESSAGES = 20;
+const TTL_MS = 30 * 60 * 1000; // 30 minutes
+const CLEANUP_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
+
+// Map<chatId, { messages: Array, lastAccess: number }>
+const conversations = new Map();
+
+/**
+ * Get conversation history for a chat
+ * @param {string} chatId - Telegram chat ID
+ * @returns {Array} - Message history array
+ */
+function getHistory(chatId) {
+  const entry = conversations.get(chatId);
+  if (!entry) return [];
+
+  // Check if expired
+  if (Date.now() - entry.lastAccess > TTL_MS) {
+    conversations.delete(chatId);
+    return [];
+  }
+
+  entry.lastAccess = Date.now();
+  return entry.messages;
+}
+
+/**
+ * Update conversation history for a chat
+ * @param {string} chatId - Telegram chat ID
+ * @param {Array} messages - New message history
+ */
+function updateHistory(chatId, messages) {
+  // Trim to max messages (keep most recent)
+  const trimmed = messages.slice(-MAX_MESSAGES);
+
+  conversations.set(chatId, {
+    messages: trimmed,
+    lastAccess: Date.now(),
+  });
+}
+
+/**
+ * Clear conversation history for a chat
+ * @param {string} chatId - Telegram chat ID
+ */
+function clearHistory(chatId) {
+  conversations.delete(chatId);
+}
+
+/**
+ * Clean up expired conversations
+ */
+function cleanupExpired() {
+  const now = Date.now();
+  for (const [chatId, entry] of conversations) {
+    if (now - entry.lastAccess > TTL_MS) {
+      conversations.delete(chatId);
+    }
+  }
+}
+
+// Start cleanup interval
+setInterval(cleanupExpired, CLEANUP_INTERVAL_MS);
+
+module.exports = {
+  getHistory,
+  updateHistory,
+  clearHistory,
+};