@soleri/forge 5.11.0 → 5.12.0

package/src/templates/telegram-bot.ts

@@ -0,0 +1,452 @@
+/**
+ * Template: Telegram bot entry point with Grammy.
+ * Generated by @soleri/forge for agents with Telegram transport.
+ */
+
+import type { AgentConfig } from '../types.js';
+
+export function generateTelegramBot(config: AgentConfig): string {
+  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);
+});
+`;
+}

package/src/templates/telegram-config.ts

@@ -0,0 +1,83 @@
+/**
+ * Template: Telegram configuration module.
+ * Generated by @soleri/forge for agents with Telegram transport.
+ */
+
+import type { AgentConfig } from '../types.js';
+
+export function generateTelegramConfig(config: AgentConfig): string {
+  return `/**
+ * Telegram Configuration — env + file-based config loading.
+ * Generated by @soleri/forge.
+ */
+
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+export interface TelegramConfig {
+  /** Telegram bot token (from @BotFather). */
+  botToken: string;
+  /** Anthropic API key. */
+  apiKey: string;
+  /** Claude model to use. Default: 'claude-sonnet-4-20250514'. */
+  model?: string;
+  /** Working directory for the agent. Default: cwd. */
+  workingDirectory?: string;
+  /** Allowed user IDs (empty = any authenticated user). */
+  allowedUsers?: number[];
+  /** Auth passphrase. If unset, auth is disabled. */
+  passphrase?: string;
+  /** Max output tokens per LLM call. Default: 16384. */
+  maxTokens?: number;
+  /** Max agent loop iterations. Default: 200. */
+  maxIterations?: number;
+}
+
+const CONFIG_DIR = join(homedir(), '.${config.id}');
+const CONFIG_FILE = join(CONFIG_DIR, 'telegram.json');
+
+/**
+ * Load Telegram config from environment variables and config file.
+ * Environment variables take priority over file-based config.
+ */
+export function loadTelegramConfig(): TelegramConfig {
+  let fileConfig: Partial<TelegramConfig> = {};
+
+  if (existsSync(CONFIG_FILE)) {
+    try {
+      fileConfig = JSON.parse(readFileSync(CONFIG_FILE, 'utf-8'));
+    } catch {
+      console.error('[config] Failed to parse telegram.json, using defaults');
+    }
+  }
+
+  const botToken = process.env.TELEGRAM_BOT_TOKEN ?? fileConfig.botToken ?? '';
+  const apiKey =
+    process.env.ANTHROPIC_API_KEY ?? fileConfig.apiKey ?? '';
+
+  if (!botToken) {
+    throw new Error(
+      'Missing TELEGRAM_BOT_TOKEN. Set via environment or ~/.${config.id}/telegram.json',
+    );
+  }
+  if (!apiKey) {
+    throw new Error(
+      'Missing ANTHROPIC_API_KEY. Set via environment or ~/.${config.id}/telegram.json',
+    );
+  }
+
+  return {
+    botToken,
+    apiKey,
+    model: process.env.ANTHROPIC_MODEL ?? fileConfig.model ?? 'claude-sonnet-4-20250514',
+    workingDirectory:
+      process.env.AGENT_WORKING_DIR ?? fileConfig.workingDirectory ?? process.cwd(),
+    allowedUsers: fileConfig.allowedUsers ?? [],
+    passphrase: fileConfig.passphrase,
+    maxTokens: fileConfig.maxTokens ?? 16384,
+    maxIterations: fileConfig.maxIterations ?? 200,
+  };
+}
+`;
+}

package/src/templates/telegram-supervisor.ts

@@ -0,0 +1,150 @@
+/**
+ * Template: Telegram supervisor — process management with restart and logging.
+ * Generated by @soleri/forge for agents with Telegram transport.
+ */
+
+import type { AgentConfig } from '../types.js';
+
+export function generateTelegramSupervisor(config: AgentConfig): string {
+  return `/**
+ * ${config.name} — Telegram Bot Supervisor.
+ * Generated by @soleri/forge.
+ *
+ * Wraps the bot process with:
+ * - Restart on crash (exponential backoff)
+ * - Restart on self-update (exit code 75)
+ * - Graceful shutdown (SIGINT/SIGTERM)
+ * - Log rotation
+ */
+
+import { spawn } from 'node:child_process';
+import { mkdirSync, appendFileSync, readdirSync, rmSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const LOG_DIR = join(homedir(), '.${config.id}', 'logs');
+const MAX_LOG_AGE_DAYS = 7;
+const SELF_UPDATE_EXIT_CODE = 75;
+
+// Exponential backoff: 1s, 2s, 4s, 8s, 16s, 30s max
+const MIN_RESTART_DELAY = 1000;
+const MAX_RESTART_DELAY = 30_000;
+
+let restartCount = 0;
+let shutdownRequested = false;
+
+function log(message: string): void {
+  const ts = new Date().toISOString();
+  const line = \`[\${ts}] [supervisor] \${message}\`;
+  console.log(line);
+  try {
+    mkdirSync(LOG_DIR, { recursive: true });
+    const date = ts.split('T')[0];
+    appendFileSync(join(LOG_DIR, \`telegram-\${date}.log\`), line + '\\n', 'utf-8');
+  } catch {
+    // Log write failure is non-critical
+  }
+}
+
+function rotateLogs(): void {
+  try {
+    const cutoff = Date.now() - MAX_LOG_AGE_DAYS * 24 * 60 * 60 * 1000;
+    const files = readdirSync(LOG_DIR);
+    for (const file of files) {
+      if (!file.startsWith('telegram-') && !file.startsWith('events-')) continue;
+      const filePath = join(LOG_DIR, file);
+      try {
+        const stat = statSync(filePath);
+        if (stat.mtimeMs < cutoff) {
+          rmSync(filePath);
+          log(\`Rotated old log: \${file}\`);
+        }
+      } catch {
+        // Skip files we can't stat
+      }
+    }
+  } catch {
+    // Rotation failure is non-critical
+  }
+}
+
+function getRestartDelay(): number {
+  const delay = Math.min(MIN_RESTART_DELAY * Math.pow(2, restartCount), MAX_RESTART_DELAY);
+  return delay;
+}
+
+function startBot(): void {
+  rotateLogs();
+  log(\`Starting bot (attempt \${restartCount + 1})...\`);
+
+  const child = spawn('node', [join(process.cwd(), 'dist', 'telegram-bot.js')], {
+    stdio: 'inherit',
+    env: { ...process.env },
+  });
+
+  child.on('exit', (code, signal) => {
+    if (shutdownRequested) {
+      log('Bot stopped (shutdown requested).');
+      process.exit(0);
+    }
+
+    if (code === SELF_UPDATE_EXIT_CODE) {
+      log('Bot requested self-update restart. Rebuilding...');
+      restartCount = 0;
+      try {
+        const { execFileSync } = require('node:child_process');
+        execFileSync('npm', ['run', 'build'], { cwd: process.cwd(), stdio: 'pipe', timeout: 60_000 });
+        log('Rebuild succeeded. Restarting...');
+      } catch (buildErr: unknown) {
+        const buildMsg = buildErr instanceof Error ? buildErr.message : String(buildErr);
+        log(\`Rebuild failed: \${buildMsg}. Attempting rollback...\`);
+        try {
+          const { execFileSync: execFile2 } = require('node:child_process');
+          execFile2('git', ['revert', 'HEAD', '--no-edit'], { cwd: process.cwd(), stdio: 'pipe', timeout: 30_000 });
+          execFile2('npm', ['run', 'build'], { cwd: process.cwd(), stdio: 'pipe', timeout: 60_000 });
+          log('Rollback succeeded. Restarting with previous code...');
+        } catch {
+          log('Rollback also failed. Restarting with current code anyway...');
+        }
+      }
+      setTimeout(startBot, 1000);
+      return;
+    }
+
+    if (code === 0) {
+      log('Bot exited cleanly.');
+      process.exit(0);
+    }
+
+    restartCount++;
+    const delay = getRestartDelay();
+    log(\`Bot exited with code \${code ?? signal}. Restarting in \${delay}ms...\`);
+    setTimeout(startBot, delay);
+  });
+
+  child.on('error', (err) => {
+    log(\`Failed to start bot: \${err.message}\`);
+    restartCount++;
+    const delay = getRestartDelay();
+    setTimeout(startBot, delay);
+  });
+
+  // Reset backoff after 60 seconds of successful running
+  setTimeout(() => {
+    if (!shutdownRequested) restartCount = 0;
+  }, 60_000);
+}
+
+// Graceful shutdown
+process.on('SIGINT', () => {
+  shutdownRequested = true;
+  log('SIGINT received, shutting down...');
+});
+process.on('SIGTERM', () => {
+  shutdownRequested = true;
+  log('SIGTERM received, shutting down...');
+});
+
+startBot();
+`;
+}