thepopebot 1.2.76-beta.10 → 1.2.76-beta.11

package/api/index.js

@@ -1,8 +1,10 @@
-import { createHash, timingSafeEqual } from 'crypto';
+import { createHash, timingSafeEqual, randomUUID } from 'crypto';
 import { createAgentJob } from '../lib/tools/create-agent-job.js';
 import { setWebhook } from '../lib/tools/telegram.js';
 import { getAgentJobStatus, fetchAgentJobLog } from '../lib/tools/github.js';
 import { getTelegramAdapter } from '../lib/channels/index.js';
+import { dispatchCommand, dispatchPreAuthCommand } from '../lib/channels/commands/index.js';
+import { getByChannelChatId, setActiveThread } from '../lib/db/user-channels.js';
 import { chat, chatStream, summarizeAgentJob } from '../lib/ai/index.js';
 import { createNotification } from '../lib/db/notifications.js';
 import { loadTriggers } from '../lib/triggers.js';
@@ -209,43 +211,65 @@ async function handleTelegramWebhook(request) {
 }
 
 /**
- * Process a normalized message through the AI layer with channel UX.
- * Message persistence is handled centrally by the AI layer.
- *
- * Uses chatStream() for progressive tool-call rendering when the adapter
- * supports it (Telegram: sends each tool call as a message, reacts on completion).
- * Falls back to chat() for adapters without streamChatResponse.
+ * Resolve the incoming channel message to a user, dispatch any slash command,
+ * and otherwise stream the message through the AI layer using the user's
+ * active session.
  */
 async function processChannelMessage(adapter, normalized) {
-  await adapter.acknowledge(normalized.metadata);
-  const stopIndicator = adapter.startProcessingIndicator(normalized.metadata);
+  const { channel, channelChatId, metadata } = normalized;
+  const binding = getByChannelChatId(channel, channelChatId);
+
+  // Unbound chat → only /verify is accepted; everything else is silently ignored.
+  if (!binding || !binding.verifiedAt) {
+    const result = await dispatchPreAuthCommand(normalized, { channel, channelChatId });
+    if (result?.handled) {
+      await adapter.sendResponse(channelChatId, result.reply, metadata);
+    }
+    return;
+  }
+
+  const ctx = { channel, channelChatId, userId: binding.userId };
+
+  // Post-auth slash commands short-circuit the AI path.
+  const cmd = await dispatchCommand(normalized, ctx);
+  if (cmd?.handled) {
+    await adapter.sendResponse(channelChatId, cmd.reply, metadata);
+    return;
+  }
+
+  await adapter.acknowledge(metadata);
+  const stopIndicator = adapter.startProcessingIndicator(metadata);
 
   try {
+    let threadId = binding.activeThreadId;
+    if (!threadId) {
+      threadId = randomUUID();
+      setActiveThread(binding.userId, channel, threadId);
+    }
+
+    const envRepo = process.env.GH_OWNER && process.env.GH_REPO
+      ? `${process.env.GH_OWNER}/${process.env.GH_REPO}`
+      : '';
+    const streamOptions = {
+      userId: binding.userId,
+      chatTitle: 'Telegram',
+      repo: envRepo,
+      branch: 'main',
+      codeMode: false,
+      codeModeType: 'code',
+    };
+
     if (adapter.streamChatResponse) {
-      const chunks = chatStream(
-        normalized.threadId,
-        normalized.text,
-        normalized.attachments,
-        { userId: 'telegram', chatTitle: 'Telegram' }
-      );
-      await adapter.streamChatResponse(normalized.metadata.chatId, chunks);
+      const chunks = chatStream(threadId, normalized.text, normalized.attachments, streamOptions);
+      await adapter.streamChatResponse(channelChatId, chunks);
     } else {
-      const response = await chat(
-        normalized.threadId,
-        normalized.text,
-        normalized.attachments,
-        { userId: 'telegram', chatTitle: 'Telegram' }
-      );
-      await adapter.sendResponse(normalized.threadId, response, normalized.metadata);
+      const response = await chat(threadId, normalized.text, normalized.attachments, streamOptions);
+      await adapter.sendResponse(channelChatId, response, metadata);
     }
   } catch (err) {
     console.error('Failed to process message with AI:', err);
     await adapter
-      .sendResponse(
-        normalized.threadId,
-        'Sorry, I encountered an error processing your message.',
-        normalized.metadata
-      )
+      .sendResponse(channelChatId, 'Sorry, I encountered an error processing your message.', metadata)
       .catch(() => {});
   } finally {
     stopIndicator();

package/bin/cli.js

@@ -277,58 +277,23 @@ async function init() {
     }
   }
 
-  // Create default skill activation symlinks
-  const defaultSkills = [];
-  const activeDir = path.join(cwd, 'skills', 'active');
-  fs.mkdirSync(activeDir, { recursive: true });
-  for (const skill of defaultSkills) {
-    const symlink = path.join(activeDir, skill);
-    if (!fs.existsSync(symlink)) {
-      createDirLink(`../library/${skill}`, symlink);
-      console.log(`  Created skills/active/${skill} → ../library/${skill}`);
+  // Create agent skill bridge symlinks (point to ../skills)
+  const skillBridges = [
+    { dir: '.pi', name: 'Pi' },
+    { dir: '.claude', name: 'Claude' },
+    { dir: '.codex', name: 'Codex' },
+    { dir: '.gemini', name: 'Gemini' },
+    { dir: '.kimi', name: 'Kimi' },
+  ];
+  for (const { dir, name } of skillBridges) {
+    const link = path.join(cwd, dir, 'skills');
+    if (!fs.existsSync(link)) {
+      fs.mkdirSync(path.dirname(link), { recursive: true });
+      createDirLink('../skills', link);
+      console.log(`  Created ${dir}/skills → ../skills`);
     }
   }
 
-  // Create .pi/skills → ../skills/active symlink
-  const piSkillsLink = path.join(cwd, '.pi', 'skills');
-  if (!fs.existsSync(piSkillsLink)) {
-    fs.mkdirSync(path.dirname(piSkillsLink), { recursive: true });
-    createDirLink('../skills/active', piSkillsLink);
-    console.log('  Created .pi/skills → ../skills/active');
-  }
-
-  // Create .claude/skills → ../skills/active symlink
-  const claudeSkillsLink = path.join(cwd, '.claude', 'skills');
-  if (!fs.existsSync(claudeSkillsLink)) {
-    fs.mkdirSync(path.dirname(claudeSkillsLink), { recursive: true });
-    createDirLink('../skills/active', claudeSkillsLink);
-    console.log('  Created .claude/skills → ../skills/active');
-  }
-
-  // Create .codex/skills → ../skills/active symlink
-  const codexSkillsLink = path.join(cwd, '.codex', 'skills');
-  if (!fs.existsSync(codexSkillsLink)) {
-    fs.mkdirSync(path.dirname(codexSkillsLink), { recursive: true });
-    createDirLink('../skills/active', codexSkillsLink);
-    console.log('  Created .codex/skills → ../skills/active');
-  }
-
-  // Create .gemini/skills → ../skills/active symlink
-  const geminiSkillsLink = path.join(cwd, '.gemini', 'skills');
-  if (!fs.existsSync(geminiSkillsLink)) {
-    fs.mkdirSync(path.dirname(geminiSkillsLink), { recursive: true });
-    createDirLink('../skills/active', geminiSkillsLink);
-    console.log('  Created .gemini/skills → ../skills/active');
-  }
-
-  // Create .kimi/skills → ../skills/active symlink
-  const kimiSkillsLink = path.join(cwd, '.kimi', 'skills');
-  if (!fs.existsSync(kimiSkillsLink)) {
-    fs.mkdirSync(path.dirname(kimiSkillsLink), { recursive: true });
-    createDirLink('../skills/active', kimiSkillsLink);
-    console.log('  Created .kimi/skills → ../skills/active');
-  }
-
 
   // Report backed-up files
   if (backedUp.length > 0) {

package/drizzle/0022_organic_apocalypse.sql

@@ -0,0 +1,16 @@
+CREATE TABLE `user_channels` (
+	`id` text PRIMARY KEY NOT NULL,
+	`user_id` text NOT NULL,
+	`channel` text NOT NULL,
+	`channel_chat_id` text,
+	`code` text,
+	`code_expires_at` integer,
+	`verified_at` integer,
+	`active_thread_id` text,
+	`created_at` integer NOT NULL,
+	`updated_at` integer NOT NULL
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `user_channels_user_channel_unique` ON `user_channels` (`user_id`,`channel`);--> statement-breakpoint
+CREATE UNIQUE INDEX `user_channels_channel_chat_id_unique` ON `user_channels` (`channel`,`channel_chat_id`);--> statement-breakpoint
+CREATE INDEX `user_channels_code_lookup` ON `user_channels` (`code`);