@soleri/forge 5.11.0 → 5.12.0

package/dist/templates/telegram-agent.js

@@ -0,0 +1,212 @@
+/**
+ * Template: Telegram agent loop — wires @soleri/core agent loop to MCP tools.
+ * Generated by @soleri/forge for agents with Telegram transport.
+ */
+export function generateTelegramAgent(config) {
+    return `/**
+ * ${config.name} — Telegram Agent Loop.
+ * Generated by @soleri/forge.
+ *
+ * Wires the @soleri/core agent loop to the agent's MCP tools.
+ */
+
+import {
+  runAgentLoop,
+  McpToolBridge,
+  createOutputCompressor,
+} from '@soleri/core';
+import type {
+  ChatMessage,
+  AgentLoopResult,
+  AgentCallbacks,
+  McpToolRegistration,
+} from '@soleri/core';
+import type { TelegramConfig } from './telegram-config.js';
+import { execFileSync } from 'node:child_process';
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+// ─── Core Tools ──────────────────────────────────────────────────────
+
+const CORE_TOOLS: McpToolRegistration[] = [
+  {
+    name: 'bash',
+    description: 'Execute a shell command. Returns stdout/stderr.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        command: { type: 'string', description: 'Shell command to execute.' },
+        timeout: { type: 'number', description: 'Timeout in ms. Default: 120000.' },
+      },
+      required: ['command'],
+    },
+    handler: async (input) => {
+      try {
+        const timeout = (input.timeout as number) ?? 120_000;
+        const output = execFileSync('/bin/sh', ['-c', input.command as string], {
+          timeout,
+          encoding: 'utf-8',
+          maxBuffer: 1024 * 1024,
+        });
+        return output;
+      } catch (err: unknown) {
+        const error = err as { stdout?: string; stderr?: string; message?: string };
+        return \`Error: \${error.stderr ?? error.stdout ?? error.message ?? 'Unknown error'}\`;
+      }
+    },
+  },
+  {
+    name: 'read_file',
+    description: 'Read a file from the filesystem.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'File path to read.' },
+      },
+      required: ['path'],
+    },
+    handler: async (input) => {
+      return readFileSync(input.path as string, 'utf-8');
+    },
+  },
+  {
+    name: 'write_file',
+    description: 'Write content to a file.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'File path to write.' },
+        content: { type: 'string', description: 'Content to write.' },
+      },
+      required: ['path', 'content'],
+    },
+    handler: async (input) => {
+      mkdirSync(dirname(input.path as string), { recursive: true });
+      writeFileSync(input.path as string, input.content as string, 'utf-8');
+      return \`Wrote \${(input.content as string).length} bytes to \${input.path}\`;
+    },
+  },
+  {
+    name: 'glob',
+    description: 'Find files matching a glob pattern.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        pattern: { type: 'string', description: 'Glob pattern.' },
+        cwd: { type: 'string', description: 'Working directory.' },
+      },
+      required: ['pattern'],
+    },
+    handler: async (input) => {
+      const cwd = (input.cwd as string) ?? process.cwd();
+      const output = execFileSync('find', ['.', '-path', input.pattern as string, '-type', 'f'], {
+        cwd,
+        encoding: 'utf-8',
+        timeout: 10_000,
+      });
+      const lines = output.trim().split('\\n').filter(Boolean).slice(0, 100);
+      return lines.length > 0 ? lines.join('\\n') : 'No files found.';
+    },
+  },
+  {
+    name: 'grep',
+    description: 'Search file contents with regex.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        pattern: { type: 'string', description: 'Regex pattern.' },
+        path: { type: 'string', description: 'File or directory to search.' },
+        type: { type: 'string', description: 'File type filter (e.g., ts, js).' },
+      },
+      required: ['pattern'],
+    },
+    handler: async (input) => {
+      const searchPath = (input.path as string) ?? '.';
+      const args = ['--no-heading', '-n', input.pattern as string, searchPath];
+      if (input.type) args.splice(2, 0, '--type', input.type as string);
+      try {
+        const output = execFileSync('rg', args, {
+          encoding: 'utf-8',
+          timeout: 10_000,
+        });
+        const lines = output.trim().split('\\n').filter(Boolean).slice(0, 50);
+        return lines.length > 0 ? lines.join('\\n') : 'No matches found.';
+      } catch {
+        return 'No matches found.';
+      }
+    },
+  },
+];
+
+// ─── Agent Factory ───────────────────────────────────────────────────
+
+export interface TelegramAgentRunner {
+  run(messages: ChatMessage[], callbacks?: AgentCallbacks): Promise<AgentLoopResult>;
+  registerTool(tool: McpToolRegistration): void;
+  getToolCount(): number;
+}
+
+export function createTelegramAgent(config: TelegramConfig): TelegramAgentRunner {
+  const bridge = new McpToolBridge({
+    compressor: createOutputCompressor({ maxLength: 4000 }),
+    maxOutput: 10_000,
+  });
+
+  // Register core tools
+  bridge.registerAll(CORE_TOOLS);
+
+  const systemPrompt = buildSystemPrompt(config);
+
+  return {
+    run: async (messages: ChatMessage[], callbacks?: AgentCallbacks) => {
+      return runAgentLoop(messages, {
+        apiKey: config.apiKey,
+        model: config.model,
+        systemPrompt,
+        tools: bridge.getTools(),
+        executor: bridge.createExecutor(),
+        maxIterations: config.maxIterations,
+        maxTokens: config.maxTokens,
+      }, callbacks);
+    },
+
+    registerTool: (tool: McpToolRegistration) => {
+      bridge.register(tool);
+    },
+
+    getToolCount: () => bridge.size,
+  };
+}
+
+// ─── System Prompt ───────────────────────────────────────────────────
+
+function buildSystemPrompt(config: TelegramConfig): string {
+  const parts: string[] = [
+    '# ${config.name}',
+    '',
+    '${config.role}',
+    '',
+    '## Environment',
+    \`- Platform: \${process.platform}\`,
+    \`- Working directory: \${config.workingDirectory ?? process.cwd()}\`,
+    \`- Date: \${new Date().toISOString().split('T')[0]}\`,
+    '',
+    '## Telegram Formatting',
+    '- Keep responses concise (under 2000 chars when possible)',
+    '- Use Markdown: **bold**, *italic*, \\\`code\\\`, \\\`\\\`\\\`code blocks\\\`\\\`\\\`',
+    '- Use bullet points for lists',
+    '- No raw JSON in responses — format for human reading',
+    '',
+    '## Available Tools',
+    '- bash: Execute shell commands',
+    '- read_file: Read file contents',
+    '- write_file: Write to files',
+    '- glob: Find files by pattern',
+    '- grep: Search file contents',
+  ];
+
+  return parts.join('\\n');
+}
+`;
+}
+//# sourceMappingURL=telegram-agent.js.map

package/dist/templates/telegram-agent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"telegram-agent.js","sourceRoot":"","sources":["../../src/templates/telegram-agent.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,MAAM,UAAU,qBAAqB,CAAC,MAAmB;IACvD,OAAO;KACJ,MAAM,CAAC,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAkLP,MAAM,CAAC,IAAI;;OAEb,MAAM,CAAC,IAAI;;;;;;;;;;;;;;;;;;;;;;;CAuBjB,CAAC;AACF,CAAC"}

package/dist/templates/telegram-bot.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Template: Telegram bot entry point with Grammy.
+ * Generated by @soleri/forge for agents with Telegram transport.
+ */
+import type { AgentConfig } from '../types.js';
+export declare function generateTelegramBot(config: AgentConfig): string;

package/dist/templates/telegram-bot.js

@@ -0,0 +1,450 @@
+/**
+ * Template: Telegram bot entry point with Grammy.
+ * Generated by @soleri/forge for agents with Telegram transport.
+ */
+export function generateTelegramBot(config) {
+    return `/**
+ * ${config.name} — Telegram Bot Entry Point.
+ * Generated by @soleri/forge.
+ *
+ * Grammy bot with middleware pipeline, session management, and agent dispatch.
+ */
+
+import { Bot } from 'grammy';
+import { loadTelegramConfig, type TelegramConfig } from './telegram-config.js';
+import { createTelegramAgent } from './telegram-agent.js';
+import {
+  ChatSessionManager,
+  ChatAuthManager,
+  TaskCancellationManager,
+  SelfUpdateManager,
+  RESTART_EXIT_CODE,
+  NotificationEngine,
+  FragmentBuffer,
+  chunkResponse,
+  detectFileIntent,
+  buildMultimodalContent,
+  saveTempFile,
+  cleanupTempFiles,
+  MAX_FILE_SIZE,
+} from '@soleri/core';
+import type { Fragment, FileInfo } from '@soleri/core';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { mkdirSync, appendFileSync } from 'node:fs';
+
+// ─── Config ──────────────────────────────────────────────────────────
+
+const CONFIG_DIR = join(homedir(), '.${config.id}');
+const SESSIONS_DIR = join(CONFIG_DIR, 'telegram-sessions');
+const AUTH_FILE = join(CONFIG_DIR, 'telegram-auth.json');
+const RESTART_FILE = join(CONFIG_DIR, 'telegram-restart.json');
+const UPLOAD_DIR = join(CONFIG_DIR, 'telegram-uploads');
+const LOG_DIR = join(CONFIG_DIR, 'logs');
+
+// ─── State ───────────────────────────────────────────────────────────
+
+const processingLocks = new Set<string>();
+let telegramConfig: TelegramConfig;
+let sessions: ChatSessionManager;
+let auth: ChatAuthManager;
+let fragmentBuffer: FragmentBuffer;
+const cancellation = new TaskCancellationManager();
+const updater = new SelfUpdateManager(RESTART_FILE);
+let notifications: NotificationEngine;
+
+// ─── Event Logger ────────────────────────────────────────────────────
+
+function logEvent(type: string, chatId: number | string, data?: Record<string, unknown>): void {
+  try {
+    mkdirSync(LOG_DIR, { recursive: true });
+    const date = new Date().toISOString().split('T')[0];
+    const entry = JSON.stringify({ ts: new Date().toISOString(), chatId, type, ...data });
+    appendFileSync(join(LOG_DIR, \`events-\${date}.jsonl\`), entry + '\\n', 'utf-8');
+  } catch {
+    // Logging failure is non-critical
+  }
+}
+
+// ─── Bot Setup ───────────────────────────────────────────────────────
+
+export async function startBot(): Promise<void> {
+  telegramConfig = loadTelegramConfig();
+
+  // Initialize infrastructure
+  sessions = new ChatSessionManager({
+    storageDir: SESSIONS_DIR,
+    ttlMs: 7_200_000, // 2 hours
+    compactionThreshold: 100,
+    compactionKeep: 40,
+  });
+  sessions.startReaper();
+
+  auth = new ChatAuthManager({
+    storagePath: AUTH_FILE,
+    passphrase: telegramConfig.passphrase,
+    allowedUsers: telegramConfig.allowedUsers,
+  });
+
+  fragmentBuffer = new FragmentBuffer(
+    { startThreshold: 4000, maxGapMs: 1500, maxParts: 12, maxTotalBytes: 50_000 },
+    (key, merged) => handleMergedMessage(key, merged),
+  );
+
+  // Initialize notification engine
+  notifications = new NotificationEngine({
+    intervalMs: 30 * 60 * 1000, // 30 minutes
+    onNotify: async (_checkId, message) => {
+      try {
+        // Send to the most recently active chat
+        const activeSessions = sessions.listActive();
+        if (activeSessions.length > 0) {
+          await bot.api.sendMessage(activeSessions[0], message, { parse_mode: 'HTML' });
+        }
+      } catch {
+        // Notification delivery failure is non-critical
+      }
+    },
+  });
+
+  const bot = new Bot(telegramConfig.botToken);
+
+  // ─── Restart Context ───────────────────────────────────────────
+
+  const restartCtx = updater.loadContext();
+  if (restartCtx) {
+    updater.clearContext();
+    try {
+      await bot.api.sendMessage(restartCtx.chatId, \`Back online! Restart reason: \${restartCtx.reason}.\`);
+      logEvent('restart_confirmed', restartCtx.chatId, { reason: restartCtx.reason });
+    } catch {
+      // Chat might not exist anymore
+    }
+  }
+
+  // ─── Commands ──────────────────────────────────────────────────
+
+  bot.command('start', async (ctx) => {
+    if (!checkAuth(ctx)) return;
+    await ctx.reply('Welcome! I am ${config.name}, ${config.role}. How can I help?');
+    logEvent('command', ctx.chat.id, { command: 'start' });
+  });
+
+  bot.command('clear', async (ctx) => {
+    if (!checkAuth(ctx)) return;
+    sessions.clear(String(ctx.chat.id));
+    await ctx.reply('Session cleared. Starting fresh.');
+    logEvent('command', ctx.chat.id, { command: 'clear' });
+  });
+
+  bot.command('health', async (ctx) => {
+    if (!checkAuth(ctx)) return;
+    const status = {
+      sessions: sessions.size,
+      authenticated: auth.authenticatedCount,
+      fragments: fragmentBuffer.pendingCount,
+    };
+    await ctx.reply(\`Health: \${JSON.stringify(status, null, 2)}\`);
+    logEvent('command', ctx.chat.id, { command: 'health' });
+  });
+
+  bot.command('help', async (ctx) => {
+    if (!checkAuth(ctx)) return;
+    await ctx.reply(
+      [
+        '<b>Commands:</b>',
+        '/start — Initialize',
+        '/clear — Clear conversation',
+        '/health — System status',
+        '/help — This message',
+        '/stop — Cancel current task',
+        '/restart — Restart the bot',
+      ].join('\\n'),
+      { parse_mode: 'HTML' },
+    );
+  });
+
+  bot.command('stop', async (ctx) => {
+    const chatId = String(ctx.chat.id);
+    const info = cancellation.cancel(chatId);
+    if (info) {
+      const ranSec = ((Date.now() - info.startedAt) / 1000).toFixed(1);
+      await ctx.reply(\`Task cancelled after \${ranSec}s.\`);
+      logEvent('command', ctx.chat.id, { command: 'stop', ranMs: Date.now() - info.startedAt });
+    } else {
+      await ctx.reply('No task is currently running.');
+    }
+  });
+
+  bot.command('restart', async (ctx) => {
+    if (!checkAuth(ctx)) return;
+    const chatId = String(ctx.chat.id);
+    const result = updater.requestRestart(chatId, 'manual');
+    if (result.initiated) {
+      await ctx.reply('Restarting... I will be back shortly.');
+      logEvent('command', ctx.chat.id, { command: 'restart' });
+      setTimeout(() => process.exit(RESTART_EXIT_CODE), 1000);
+    } else {
+      await ctx.reply(\`Restart failed: \${result.error}\`);
+    }
+  });
+
+  // ─── Photo Messages ────────────────────────────────────────────
+
+  bot.on('message:photo', async (ctx) => {
+    if (!checkAuth(ctx)) return;
+    const chatId = String(ctx.chat.id);
+
+    try {
+      const photo = ctx.message.photo[ctx.message.photo.length - 1]; // Largest size
+      const file = await ctx.api.getFile(photo.file_id);
+      if (!file.file_path) {
+        await ctx.reply('Could not download photo.');
+        return;
+      }
+
+      const url = \`https://api.telegram.org/file/bot\${telegramConfig.botToken}/\${file.file_path}\`;
+      const resp = await fetch(url);
+      const buffer = Buffer.from(await resp.arrayBuffer());
+
+      if (buffer.length > MAX_FILE_SIZE) {
+        await ctx.reply('File too large (max 20MB). Please compress and try again.');
+        return;
+      }
+
+      const caption = ctx.message.caption ?? 'What do you see in this image?';
+      const fileInfo: FileInfo = {
+        name: file.file_path.split('/').pop() ?? 'photo.jpg',
+        mimeType: 'image/jpeg',
+        size: buffer.length,
+        data: buffer,
+      };
+
+      const intent = detectFileIntent(fileInfo.name, fileInfo.mimeType, caption);
+      const content = buildMultimodalContent(fileInfo, intent);
+
+      // Build multimodal user message for agent
+      const multimodalText = content.type === 'text'
+        ? \`[File: \${fileInfo.name}]\\n\${content.content}\\n\\n\${caption}\`
+        : \`[Image: \${fileInfo.name}, \${Math.round(fileInfo.size / 1024)}KB]\\n\${caption}\`;
+
+      logEvent('photo_in', ctx.chat.id, { size: buffer.length, intent });
+      await dispatchToAgent(chatId, multimodalText, ctx);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      await ctx.reply('Failed to process photo.');
+      logEvent('error', ctx.chat.id, { error: msg, type: 'photo' });
+    }
+  });
+
+  // ─── Document Messages ─────────────────────────────────────────
+
+  bot.on('message:document', async (ctx) => {
+    if (!checkAuth(ctx)) return;
+    const chatId = String(ctx.chat.id);
+    const doc = ctx.message.document;
+
+    try {
+      if (doc.file_size && doc.file_size > MAX_FILE_SIZE) {
+        await ctx.reply('File too large (max 20MB). Please compress and try again.');
+        return;
+      }
+
+      const file = await ctx.api.getFile(doc.file_id);
+      if (!file.file_path) {
+        await ctx.reply('Could not download document.');
+        return;
+      }
+
+      const url = \`https://api.telegram.org/file/bot\${telegramConfig.botToken}/\${file.file_path}\`;
+      const resp = await fetch(url);
+      const buffer = Buffer.from(await resp.arrayBuffer());
+
+      const filename = doc.file_name ?? 'document';
+      const mimeType = doc.mime_type ?? 'application/octet-stream';
+      const caption = ctx.message.caption ?? '';
+
+      const intent = detectFileIntent(filename, mimeType, caption);
+      const fileInfo: FileInfo = { name: filename, mimeType, size: buffer.length, data: buffer };
+
+      if (intent === 'intake') {
+        saveTempFile(UPLOAD_DIR, filename, buffer);
+        await ctx.reply(\`Saved \${filename} for knowledge ingestion.\`);
+        logEvent('document_intake', ctx.chat.id, { filename, size: buffer.length });
+        return;
+      }
+
+      const content = buildMultimodalContent(fileInfo, intent);
+      const userText = content.type === 'text'
+        ? \`[File: \${filename}]\\n\${content.content}\${caption ? '\\n\\n' + caption : ''}\`
+        : \`[Document: \${filename}, \${Math.round(buffer.length / 1024)}KB]\${caption ? '\\n' + caption : ''}\`;
+
+      logEvent('document_in', ctx.chat.id, { filename, size: buffer.length, intent });
+      await dispatchToAgent(chatId, userText, ctx);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      await ctx.reply('Failed to process document.');
+      logEvent('error', ctx.chat.id, { error: msg, type: 'document' });
+    }
+  });
+
+  // ─── Text Messages ────────────────────────────────────────────
+
+  bot.on('message:text', async (ctx) => {
+    const text = ctx.message.text;
+    const chatId = String(ctx.chat.id);
+    const userId = ctx.from?.id;
+
+    // Auth check — if passphrase is set, check if user is authenticated
+    if (auth.enabled && !auth.isAuthenticated(String(userId))) {
+      if (telegramConfig.passphrase && text === telegramConfig.passphrase) {
+        auth.authenticate(String(userId), text);
+        await ctx.reply('Authenticated! How can I help?');
+        logEvent('auth', ctx.chat.id, { userId });
+        return;
+      }
+      await ctx.reply('Please authenticate first.');
+      return;
+    }
+
+    logEvent('message_in', ctx.chat.id, { length: text.length });
+
+    // Fragment buffering
+    const fragment: Fragment = {
+      text,
+      messageId: ctx.message.message_id,
+      receivedAt: Date.now(),
+    };
+
+    const buffered = fragmentBuffer.receive(chatId, fragment);
+    if (buffered) return; // Wait for more fragments
+
+    // Process immediately
+    await dispatchToAgent(chatId, text, ctx);
+  });
+
+  // ─── Error Handling ───────────────────────────────────────────
+
+  bot.catch((err) => {
+    console.error('[bot] Error:', err.message);
+    logEvent('error', 'global', { error: err.message });
+  });
+
+  // ─── Start ────────────────────────────────────────────────────
+
+  console.log('[${config.id}] Starting Telegram bot...');
+  logEvent('bot_start', 'system');
+
+  // Start notification polling and periodic temp cleanup
+  notifications.start();
+  setInterval(() => cleanupTempFiles(UPLOAD_DIR, 3_600_000), 3_600_000); // 1h
+
+  process.on('SIGINT', () => shutdown(bot));
+  process.on('SIGTERM', () => shutdown(bot));
+
+  await bot.start();
+}
+
+// ─── Agent Dispatch ──────────────────────────────────────────────────
+
+async function dispatchToAgent(
+  chatId: string,
+  text: string,
+  ctx: { reply: (text: string, options?: Record<string, unknown>) => Promise<unknown> },
+): Promise<void> {
+  if (processingLocks.has(chatId)) {
+    await ctx.reply('I am still working on your previous request. Please wait.');
+    return;
+  }
+
+  processingLocks.add(chatId);
+  const signal = cancellation.create(chatId, 'Processing message');
+
+  try {
+    // Append user message
+    sessions.appendMessage(chatId, {
+      role: 'user',
+      content: text,
+      timestamp: Date.now(),
+    });
+
+    // Run agent with cancellation signal
+    const agent = createTelegramAgent(telegramConfig);
+    const session = sessions.getOrCreate(chatId);
+    const result = await agent.run(session.messages, { signal });
+
+    // Append agent response
+    sessions.appendMessages(chatId, result.newMessages);
+
+    // Send response in chunks
+    const chunks = chunkResponse(result.text, { maxChunkSize: 4000, format: 'html' });
+    for (const chunk of chunks) {
+      try {
+        await ctx.reply(chunk, { parse_mode: 'HTML' });
+      } catch {
+        // Fallback to plain text if HTML fails
+        await ctx.reply(chunk);
+      }
+    }
+
+    logEvent('response_out', chatId, {
+      iterations: result.iterations,
+      toolCalls: result.toolCalls,
+      chunks: chunks.length,
+    });
+  } catch (error) {
+    if (signal.aborted) {
+      logEvent('cancelled', chatId);
+      return; // Already notified user via /stop handler
+    }
+    const msg = error instanceof Error ? error.message : String(error);
+    console.error(\`[agent] Error for chat \${chatId}:\`, msg);
+    await ctx.reply('Sorry, I encountered an error. Please try again.');
+    logEvent('error', chatId, { error: msg });
+  } finally {
+    cancellation.complete(chatId);
+    processingLocks.delete(chatId);
+  }
+}
+
+// ─── Fragment Handler ────────────────────────────────────────────────
+
+function handleMergedMessage(key: string, merged: string): void {
+  // key is the chatId — dispatch the merged text
+  // Note: we don't have the ctx here, so we use the bot API directly
+  // In a real implementation, you'd store the ctx reference
+  console.log(\`[fragment] Merged \${merged.length} chars for \${key}\`);
+}
+
+// ─── Auth Helper ─────────────────────────────────────────────────────
+
+function checkAuth(ctx: { from?: { id: number }; reply: (text: string) => Promise<unknown> }): boolean {
+  if (!auth.enabled) return true;
+  if (auth.isAuthenticated(String(ctx.from?.id))) return true;
+  ctx.reply('Please authenticate first.');
+  return false;
+}
+
+// ─── Shutdown ────────────────────────────────────────────────────────
+
+function shutdown(bot: Bot): void {
+  console.log('[${config.id}] Shutting down...');
+  logEvent('bot_stop', 'system');
+  cancellation.cancelAll();
+  notifications.stop();
+  cleanupTempFiles(UPLOAD_DIR);
+  fragmentBuffer.close();
+  sessions.close();
+  bot.stop();
+  process.exit(0);
+}
+
+// ─── Main ────────────────────────────────────────────────────────────
+
+startBot().catch((err) => {
+  console.error('[${config.id}] Fatal:', err);
+  process.exit(1);
+});
+`;
+}
+//# sourceMappingURL=telegram-bot.js.map

package/dist/templates/telegram-bot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"telegram-bot.js","sourceRoot":"","sources":["../../src/templates/telegram-bot.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,MAAM,UAAU,mBAAmB,CAAC,MAAmB;IACrD,OAAO;KACJ,MAAM,CAAC,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCA+BuB,MAAM,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCA2FX,MAAM,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA8M9C,MAAM,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgGT,MAAM,CAAC,EAAE;;;;;;;;;;;;;;oBAcP,MAAM,CAAC,EAAE;;;CAG5B,CAAC;AACF,CAAC"}

package/dist/templates/telegram-config.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Template: Telegram configuration module.
+ * Generated by @soleri/forge for agents with Telegram transport.
+ */
+import type { AgentConfig } from '../types.js';
+export declare function generateTelegramConfig(config: AgentConfig): string;