@ducci/jarvis 1.0.9 → 1.0.11

package/docs/agent.md

@@ -198,7 +198,7 @@ Seed tool included for sanity checks:
 Jarvis uses the provider tool-calling API:
 
 1. The model returns an assistant message containing a `tool_calls` array.
-2. Jarvis appends that assistant message to the conversation history as-is.
+2. Jarvis normalizes each tool call before appending to the conversation history: if `function.arguments` is missing or empty, it is set to `"{}"`. Some models (especially smaller/free ones) omit `arguments` for no-arg tools. Storing a malformed tool call would cause the next API request to fail with a 400 validation error.
 3. Jarvis executes those tools in order, serially.
 4. Each tool result is appended to the conversation as a `role: "tool"` message with a matching `tool_call_id`.
 5. Jarvis calls the model again with the updated conversation.
@@ -447,7 +447,13 @@ Tool inputs/outputs:
 
 - Model call failures: try the selected model once, then one fallback model attempt. If both fail, end the run with a `500` error and a clear message.
 - Tool failures: pass the error result back to the model and continue the loop. Best case would be that the next model response include another tool call to fix the previous tool call. All tool errors (especially `exec` failures) must be reported in the `logSummary` with enough detail for a human to understand the cause.
-- Malformed JSON on final response: log the failure and stop the run with a formatted error message.
+- Malformed JSON on final response: attempt two recovery steps before giving up:
+  1. **Fallback model retry** — call the fallback model with the same conversation messages (the bad response is not saved to the session yet). If this produces valid JSON, use it and continue normally.
+  2. **Nudge retry** — if the fallback model also returns non-JSON, append a temporary nudge message to the conversation (not saved to the session) and call `callModelWithFallback` once more:
+     ```
+     Your previous response was not valid JSON. Respond only with the required JSON object: {"response": "...", "logSummary": "..."}
+     ```
+  3. **Give up** — if all three attempts fail, return `format_error` without pushing any assistant content to the session. The nudge message is never persisted regardless of outcome.
 
 **Error Payload Structure**:
 
@@ -462,6 +468,14 @@ Tool inputs/outputs:
 - Use `500 Internal Server Error` for API failures, tool runtime errors, or model communication issues.
 - Always append a log entry on failure so the outcome is visible in the session log.
 
+**Synthetic error note on failure**: when a run ends with `model_error` or `format_error`, a synthetic assistant message is appended to the session before saving:
+
+```
+[System: Previous run failed (model_error): <logSummary>. Error detail: <errorDetail JSON>]
+```
+
+The full `errorDetail` (provider error body, HTTP status, etc.) is included so the model has enough information to understand and potentially recover from the failure without needing to call `read_session_log`. Without this, the session would contain a dangling user message with no reply, and the model would have no way to understand or recover from the failure.
+
 Model configuration:
 
 - Selected model ID is stored in the same config file created during setup.

package/docs/cli.md

@@ -38,7 +38,8 @@ Lifecycle management is handled by the CLI using the **programmatic PM2 API** fo
 - Stops the background process named `jarvis-server` using PM2.
 
 ### `jarvis status`
-- (Planned) Displays the current status of the `jarvis-server` process.
+- Displays the current status of the `jarvis-server` process.
+- Outputs: name, status, PID, uptime, restart count, and log file path.
 
 ## Local Development
 

package/docs/setup.md

@@ -71,11 +71,54 @@ Within this directory:
       "port": 18008
     }
     ```
+  - `conversations/` — per-session conversation history
+  - `tools/tools.json` — seed and custom tool definitions
+  - `user-info.json` — key-value facts about the user (written by `save_user_info` tool)
 - `logs/`
-  - `server.log`
+  - `server.log` — PM2 stdout/stderr (process-level log)
+  - `session-<id>.jsonl` — structured per-session JSONL logs written by the agent
+
+## Telegram Channel Setup (Optional)
+
+At the end of `jarvis setup`, after the model selection step, the user is asked whether they want to configure the Telegram channel:
+
+```
+Do you want to configure the Telegram channel? (y/N)
+```
+
+If yes:
+
+1. Bot token step
+   - Check if `TELEGRAM_BOT_TOKEN` already exists in `.env`.
+   - If it exists, prompt to keep or replace.
+   - If missing, prompt for a new token (password input).
+   - Write/update `TELEGRAM_BOT_TOKEN=...` in `.env`.
+
+2. Allowed user IDs step
+   - Read current value from `channels.telegram.allowedUserIds` in `settings.json`.
+   - If values exist, show them and prompt to keep or replace.
+   - If missing, prompt for one or more Telegram user IDs (comma-separated input, parsed as integers).
+   - Write to `channels.telegram.allowedUserIds` in `settings.json`.
+
+If the user answers no, the Telegram step is skipped entirely and the existing channel config (if any) is left unchanged.
+
+## Post-Setup Restart
+
+After `jarvis setup` completes (including the optional Telegram step), the CLI checks whether `jarvis-server` is currently running via PM2.
+
+If the server is running, prompt:
+
+```
+Server is running. Restart now to apply changes? (Y/n)
+```
+
+- If yes (or Enter): restart the server using PM2 restart.
+- If no: print a reminder — `Run \`jarvis stop && jarvis start\` when ready to apply changes.`
+
+If the server is not running, no prompt is shown.
 
 ## First Run Flow
 
 1. User installs Jarvis globally.
-2. User runs `jarvis setup` to configure API keys and model.
+2. User runs `jarvis setup` to configure API key, model, and optionally the Telegram channel.
 3. User runs `jarvis start` to launch the background server.

package/docs/telegram.md

@@ -0,0 +1,235 @@
+# Telegram Channel
+
+This document specifies the Telegram channel adapter for Jarvis. It is intended as the implementation source of truth.
+
+## Goals
+
+- Thin adapter — no agent logic lives here; all intelligence is in the existing agent layer
+- Long-polling via grammy-runner for reliable, concurrent update handling
+- Session continuity — each Telegram user resumes the same Jarvis session across messages
+- Runs inside the `jarvis-server` process — no second process or PM2 entry needed
+- Allowlist-based access — only messages from configured user IDs are processed
+
+## Architecture
+
+The Telegram channel starts as part of the Jarvis server process. When the server boots, it checks if `TELEGRAM_BOT_TOKEN` is set in `.env`. If present, it initializes the bot and starts long polling alongside the Express server.
+
+The channel calls the agent layer directly (no HTTP hop) — it imports and calls the same internal function that the HTTP handler uses. The `chat_id → sessionId` mapping is maintained by the channel and passed into the agent call the same way the HTTP handler passes a `sessionId`.
+
+```
+Telegram user
+    ↓ (text message)
+Telegram Bot API  ←→  grammy-runner (long polling)
+    ↓
+Channel adapter (src/channels/telegram/index.js)
+    ↓ direct function call
+Agent layer (src/server/agent.js)
+    ↓
+Channel adapter
+    ↓ sendMessage
+Telegram user
+```
+
+## Dependencies
+
+- `grammy` — Telegram bot framework
+- `@grammyjs/runner` — concurrent long polling runner
+
+These are added to the root `package.json`.
+
+## File Layout
+
+```
+src/channels/telegram/
+├── index.js        — bot setup, allowlist guard, message handler, polling start
+└── sessions.js     — chat_id → sessionId mapping (load/save)
+```
+
+Persistent state:
+
+```
+~/.jarvis/data/channels/telegram/sessions.json
+```
+
+## Configuration
+
+**Bot token** — stored in `~/.jarvis/.env` (it is a secret):
+
+```
+TELEGRAM_BOT_TOKEN=<token from BotFather>
+```
+
+**Allowed user IDs** — stored in `~/.jarvis/data/config/settings.json` (it is config):
+
+```json
+{
+  "selectedModel": "...",
+  "channels": {
+    "telegram": {
+      "allowedUserIds": [123456789]
+    }
+  }
+}
+```
+
+If `TELEGRAM_BOT_TOKEN` is absent from `.env` at server startup, the Telegram channel is silently skipped — the server starts normally without it.
+
+## Allowlist Guard
+
+Every incoming message is checked against `allowedUserIds` before any processing occurs. The check uses `ctx.from.id` (the sender's Telegram user ID).
+
+- If the sender is on the allowlist: process the message normally.
+- If the sender is not on the allowlist: silently ignore — no reply, no log entry. This avoids confirming that the bot exists and is active.
+
+## Session Mapping
+
+Each Telegram `chat_id` (a number) maps to a Jarvis `sessionId` (a UUID string). The mapping persists to disk so sessions survive process restarts.
+
+Path:
+
+```
+~/.jarvis/data/channels/telegram/sessions.json
+```
+
+Schema:
+
+```json
+{
+  "12345678": "550e8400-e29b-41d4-a716-446655440000"
+}
+```
+
+`sessions.js` exposes:
+
+- `load()` — read the file from disk; returns an empty object if missing
+- `save(map)` — write the full map to disk (creates parent directories if needed)
+
+The map is loaded once at startup and held in memory. It is written to disk after every new session is created (i.e. after the first message from a new user).
+
+## Message Handler
+
+On each incoming Telegram text message:
+
+1. Check `ctx.from.id` against `allowedUserIds` — silently drop if not allowed
+2. Read `chat_id` from `ctx.chat.id`
+3. Look up `sessionId` in the in-memory map (may be `undefined` for new users)
+4. Start a typing indicator interval (see below)
+5. Call the agent function directly with `{ sessionId, message: ctx.message.text }`
+6. If this was the first message (`sessionId` was `undefined`), store the returned `sessionId` in the map and save to disk
+7. Send `response` back to the user via `ctx.reply(response)`
+8. Clear the typing indicator interval
+
+On any error during the agent call, clear the interval and reply with:
+
+```
+Sorry, something went wrong. Please try again.
+```
+
+## Typing Indicator
+
+Telegram's `sendChatAction('typing')` shows a "typing…" indicator in the chat, but it expires after **5 seconds**. A single call before the agent runs is not sufficient — the agent can take well over 5 seconds when tool use or multiple handoffs are involved.
+
+The solution is to send the action once immediately, then repeat it on a 4-second interval while the agent is running. The interval fires just under the 5-second expiry so the indicator stays alive continuously. The interval is always cleared in a `finally` block to avoid leaking it on errors.
+
+```js
+await ctx.api.sendChatAction(chatId, 'typing');
+const typingInterval = setInterval(() => {
+  ctx.api.sendChatAction(chatId, 'typing').catch(() => {});
+}, 4000);
+
+try {
+  const result = await handleChat(...);
+  // ...
+} finally {
+  clearInterval(typingInterval);
+}
+```
+
+Errors on the interval call are silently swallowed (`.catch(() => {})`) — a failed heartbeat should never abort the agent run.
+
+## Long Polling with grammy-runner
+
+Use `run(bot)` from `@grammyjs/runner` instead of `bot.start()`. The runner fetches updates concurrently and processes them with a default concurrency level.
+
+```js
+import { Bot } from 'grammy'
+import { run } from '@grammyjs/runner'
+
+const bot = new Bot(process.env.TELEGRAM_BOT_TOKEN)
+
+bot.on('message:text', async (ctx) => { /* ... */ })
+
+run(bot)
+```
+
+The runner handles graceful shutdown on `SIGINT`/`SIGTERM` automatically. The server's existing shutdown logic does not need to change.
+
+## Server Integration
+
+The Telegram channel is initialized from the server entry point after the Express server is ready:
+
+```js
+// src/server/app.js (or equivalent entry point)
+import { startTelegramChannel } from '../channels/telegram/index.js'
+
+// after app.listen(...)
+startTelegramChannel()
+```
+
+`startTelegramChannel()` checks for `TELEGRAM_BOT_TOKEN` and exits silently if it is not set. No error is thrown.
+
+## CLI Integration
+
+The Telegram channel is configured as an optional step inside `jarvis setup` — there is no separate command. The full setup flow is specified in [docs/setup.md](./setup.md). After setup completes, the CLI offers to restart the server automatically.
+
+## Logging
+
+Log lines use a simple prefix format, written to stdout (captured by PM2 alongside server logs in `~/.jarvis/logs/`):
+
+```
+[telegram] channel started
+[telegram] incoming chat_id=12345678
+[telegram] session resolved sessionId=550e8400
+[telegram] response sent chat_id=12345678
+[telegram] error chat_id=12345678: <error message>
+```
+
+No JSONL session logging — that is handled by the agent layer for every run.
+
+## Commands
+
+### `/new` — Start a fresh session
+
+Sending `/new` resets the conversation. The `chat_id → sessionId` mapping for the sender is removed from the in-memory map and from `sessions.json` on disk. The underlying session file is left on disk (not deleted) — it is simply unlinked from the Telegram chat.
+
+The next text message after `/new` will create a new session as if the user were messaging for the first time.
+
+**Command registration**
+
+Commands are registered with the Telegram Bot API at startup via `bot.api.setMyCommands()`. This makes them visible to users in two places:
+
+- The autocomplete menu that appears when the user types `/` in the chat input
+- The `⌘` menu button next to the chat input field
+
+Without registration the command still works if typed manually, but users would not see it suggested. Registration is idempotent — calling `setMyCommands()` on every startup is safe.
+
+```js
+await bot.api.setMyCommands([
+  { command: 'new', description: 'Start a fresh session' },
+]);
+```
+
+**Behavior summary**
+
+| State | What happens |
+|---|---|
+| User sends `/new`, has an existing session | Session unlinked, confirmation sent: "New session started." |
+| User sends `/new`, no session exists yet | No-op, same confirmation sent |
+| Next text message after `/new` | New session created, mapped to `chat_id` |
+
+## Non-Goals (v1)
+
+- No support for photos, files, or other media types (text only)
+- No inline keyboards or callback queries
+- No group chat support (only private chats)
+- No message editing or deletion handling

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ducci/jarvis",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "A fully automated agent system that lives on a server.",
   "main": "./src/index.js",
   "type": "module",
@@ -36,10 +36,12 @@
   },
   "license": "ISC",
   "dependencies": {
+    "@grammyjs/runner": "^2.0.3",
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "dotenv": "^17.3.1",
     "express": "^5.2.1",
+    "grammy": "^1.40.1",
     "inquirer": "^12.11.1",
     "openai": "^6.22.0",
     "pm2": "^6.0.14"

package/src/channels/telegram/index.js

@@ -0,0 +1,70 @@
+import { Bot } from 'grammy';
+import { run } from '@grammyjs/runner';
+import { handleChat } from '../../server/agent.js';
+import { load, save } from './sessions.js';
+
+export async function startTelegramChannel(config) {
+  const { token, allowedUserIds } = config.telegram;
+
+  if (!token) return;
+
+  const bot = new Bot(token);
+  const sessions = load();
+
+  await bot.api.setMyCommands([
+    { command: 'new', description: 'Start a fresh session' },
+  ]);
+
+  bot.command('new', async (ctx) => {
+    const userId = ctx.from?.id;
+    if (!allowedUserIds.includes(userId)) return;
+
+    const chatId = ctx.chat.id;
+    if (sessions[chatId]) {
+      delete sessions[chatId];
+      save(sessions);
+      console.log(`[telegram] session unlinked chat_id=${chatId}`);
+    }
+
+    await ctx.reply('New session started.');
+  });
+
+  bot.on('message:text', async (ctx) => {
+    const userId = ctx.from?.id;
+
+    // Allowlist guard — silently ignore unauthorized users
+    if (!allowedUserIds.includes(userId)) return;
+
+    const chatId = ctx.chat.id;
+    const sessionId = sessions[chatId] || null;
+
+    console.log(`[telegram] incoming chat_id=${chatId}`);
+
+    await ctx.api.sendChatAction(chatId, 'typing');
+    const typingInterval = setInterval(() => {
+      ctx.api.sendChatAction(chatId, 'typing').catch(() => {});
+    }, 4000);
+
+    try {
+      const result = await handleChat(config, sessionId, ctx.message.text);
+
+      // Persist new session mapping on first message
+      if (!sessions[chatId]) {
+        sessions[chatId] = result.sessionId;
+        save(sessions);
+        console.log(`[telegram] session created sessionId=${result.sessionId.slice(0, 8)}`);
+      }
+
+      await ctx.reply(result.response);
+      console.log(`[telegram] response sent chat_id=${chatId}`);
+    } catch (e) {
+      console.error(`[telegram] error chat_id=${chatId}: ${e.message}`);
+      await ctx.reply('Sorry, something went wrong. Please try again.');
+    } finally {
+      clearInterval(typingInterval);
+    }
+  });
+
+  run(bot);
+  console.log('[telegram] channel started');
+}

package/src/channels/telegram/sessions.js

@@ -0,0 +1,18 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const sessionsFile = path.join(os.homedir(), '.jarvis', 'data', 'channels', 'telegram', 'sessions.json');
+
+export function load() {
+  try {
+    return JSON.parse(fs.readFileSync(sessionsFile, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+export function save(map) {
+  fs.mkdirSync(path.dirname(sessionsFile), { recursive: true });
+  fs.writeFileSync(sessionsFile, JSON.stringify(map, null, 2), 'utf8');
+}

package/src/index.js

@@ -7,10 +7,13 @@ import path from 'path';
 import fs from 'fs';
 import os from 'os';
 import pm2 from 'pm2';
+import inquirer from 'inquirer';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
+const { version } = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8'));
+
 const JARVIS_DIR = path.join(os.homedir(), '.jarvis');
 const ENV_FILE = path.join(JARVIS_DIR, '.env');
 const SETTINGS_FILE = path.join(JARVIS_DIR, 'data', 'config', 'settings.json');
@@ -83,19 +86,57 @@ function pm2Describe() {
   });
 }
 
+function pm2Restart() {
+  return new Promise((resolve, reject) => {
+    pm2.restart(PROCESS_NAME, (err) => {
+      if (err) reject(err);
+      else resolve();
+    });
+  });
+}
+
 const program = new Command();
 
 program
   .name('jarvis')
   .description('A fully automated agent system that lives on a server.')
-  .version('1.0.0');
+  .version(version);
 
 program
   .command('setup')
   .description('Run interactive onboarding to configure API key and model.')
-  .action(() => {
+  .action(async () => {
     const onboardingScript = path.join(__dirname, 'scripts', 'onboarding.js');
     spawnSync('node', [onboardingScript], { stdio: 'inherit' });
+
+    // Offer to restart the server if it is currently running
+    try {
+      await connectPm2();
+      const desc = await pm2Describe().catch(() => []);
+      const isRunning = desc.length > 0 && desc[0].pm2_env?.status === 'online';
+      pm2.disconnect();
+
+      if (isRunning) {
+        const { doRestart } = await inquirer.prompt([
+          {
+            type: 'confirm',
+            name: 'doRestart',
+            message: 'Server is running. Restart now to apply changes?',
+            default: true
+          }
+        ]);
+        if (doRestart) {
+          await connectPm2();
+          await pm2Restart();
+          pm2.disconnect();
+          console.log('Jarvis server restarted.');
+        } else {
+          console.log('Run `jarvis stop && jarvis start` when ready to apply changes.');
+        }
+      }
+    } catch {
+      // PM2 not available or server not managed — silently skip
+    }
   });
 
 program

package/src/scripts/onboarding.js

@@ -17,30 +17,24 @@ function ensureDirectories() {
   fs.mkdirSync(logsDir, { recursive: true });
 }
 
-function loadEnv() {
+function loadEnvVar(key) {
   if (fs.existsSync(envFile)) {
     const content = fs.readFileSync(envFile, 'utf8');
-    const match = content.match(/^OPENROUTER_API_KEY=(.*)$/m);
-    if (match) {
-      return match[1].trim();
-    }
+    const match = content.match(new RegExp(`^${key}=(.*)$`, 'm'));
+    if (match) return match[1].trim();
   }
   return null;
 }
 
-function saveEnv(apiKey) {
-  let content = '';
-  if (fs.existsSync(envFile)) {
-    content = fs.readFileSync(envFile, 'utf8');
-    if (content.match(/^OPENROUTER_API_KEY=/m)) {
-      content = content.replace(/^OPENROUTER_API_KEY=.*$/m, `OPENROUTER_API_KEY=${apiKey}`);
-    } else {
-      content += `\nOPENROUTER_API_KEY=${apiKey}\n`;
-    }
+function saveEnvVar(key, value) {
+  let content = fs.existsSync(envFile) ? fs.readFileSync(envFile, 'utf8') : '';
+  const line = `${key}=${value}`;
+  if (content.match(new RegExp(`^${key}=`, 'm'))) {
+    content = content.replace(new RegExp(`^${key}=.*$`, 'm'), line);
   } else {
-    content = `OPENROUTER_API_KEY=${apiKey}\n`;
+    content = content ? `${content.trim()}\n${line}\n` : `${line}\n`;
   }
-  fs.writeFileSync(envFile, content.trim() + '\n', 'utf8');
+  fs.writeFileSync(envFile, content, 'utf8');
 }
 
 function loadSettings() {
@@ -83,7 +77,7 @@ async function run() {
   console.log(chalk.green.bold('\n=== Jarvis Setup ===\n'));
 
   // --- API KEY STEP ---
-  let existingKey = loadEnv();
+  let existingKey = loadEnvVar('OPENROUTER_API_KEY');
   let apiKey = existingKey;
 
   if (existingKey) {
@@ -106,7 +100,7 @@ async function run() {
         }
       ]);
       apiKey = newKey;
-      saveEnv(apiKey);
+      saveEnvVar('OPENROUTER_API_KEY', apiKey);
       console.log(chalk.green('API key updated.'));
     }
   } else {
@@ -119,7 +113,7 @@ async function run() {
       }
     ]);
     apiKey = newKey;
-    saveEnv(apiKey);
+    saveEnvVar('OPENROUTER_API_KEY', apiKey);
     console.log(chalk.green('API key saved.'));
   }
 
@@ -230,7 +224,83 @@ async function run() {
 
   saveSettings(settings);
   console.log(chalk.green(`\nModel ${chalk.bold(selectedModel)} saved to settings.`));
-  console.log(chalk.green.bold('Setup complete! You can now start the Jarvis server.'));
+
+  // --- TELEGRAM CHANNEL STEP (OPTIONAL) ---
+  const { configureTelegram } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'configureTelegram',
+      message: 'Do you want to configure the Telegram channel?',
+      default: false
+    }
+  ]);
+
+  if (configureTelegram) {
+    // Bot token
+    const existingToken = loadEnvVar('TELEGRAM_BOT_TOKEN');
+    let keepToken = false;
+    if (existingToken) {
+      const { keep } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'keep',
+          message: 'A TELEGRAM_BOT_TOKEN is already configured. Do you want to keep it?',
+          default: true
+        }
+      ]);
+      keepToken = keep;
+    }
+    if (!keepToken) {
+      const { token } = await inquirer.prompt([
+        {
+          type: 'password',
+          name: 'token',
+          message: 'Enter your Telegram bot token (from BotFather):',
+          validate: (input) => input.trim().length > 0 || 'Bot token cannot be empty.'
+        }
+      ]);
+      saveEnvVar('TELEGRAM_BOT_TOKEN', token.trim());
+      console.log(chalk.green('Telegram bot token saved.'));
+    }
+
+    // Allowed user IDs
+    const existingIds = settings.channels?.telegram?.allowedUserIds;
+    let keepIds = false;
+    if (existingIds && existingIds.length > 0) {
+      const { keep } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'keep',
+          message: `Allowed Telegram user IDs are already configured (${existingIds.join(', ')}). Keep them?`,
+          default: true
+        }
+      ]);
+      keepIds = keep;
+    }
+    if (!keepIds) {
+      const { rawIds } = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'rawIds',
+          message: 'Enter allowed Telegram user ID(s), comma-separated:',
+          validate: (input) => {
+            const parts = input.split(',').map(s => s.trim()).filter(Boolean);
+            if (parts.length === 0) return 'At least one user ID is required.';
+            if (parts.some(p => !/^\d+$/.test(p))) return 'All values must be numeric user IDs.';
+            return true;
+          }
+        }
+      ]);
+      const ids = rawIds.split(',').map(s => parseInt(s.trim(), 10));
+      if (!settings.channels) settings.channels = {};
+      if (!settings.channels.telegram) settings.channels.telegram = {};
+      settings.channels.telegram.allowedUserIds = ids;
+      saveSettings(settings);
+      console.log(chalk.green(`Allowed user IDs saved: ${ids.join(', ')}`));
+    }
+  }
+
+  console.log(chalk.green.bold('\nSetup complete!'));
 }
 
 run().catch(error => {