@ducci/jarvis 1.0.78 → 1.0.80

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ducci/jarvis",
-  "version": "1.0.78",
+  "version": "1.0.80",
   "description": "A fully automated agent system that lives on a server.",
   "main": "./src/index.js",
   "type": "module",

package/src/channels/telegram/index.js

@@ -1,6 +1,12 @@
 import fs from 'fs';
 import path from 'path';
-import { Bot } from 'grammy';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+import { createRequire } from 'module';
+const _require = createRequire(import.meta.url);
+const { version: JARVIS_VERSION } = _require('../../../package.json');
+import { Bot, InlineKeyboard } from 'grammy';
 import { run } from '@grammyjs/runner';
 import { handleChat, requestAbort } from '../../server/agent.js';
 import { loadSession } from '../../server/sessions.js';
@@ -90,6 +96,33 @@ async function sendMessage(api, chatId, text, sessionId) {
   }
 }
 
+// Known model context windows in tokens. Used by /context command.
+// Partial match: checked with model.includes(key) so short keys like 'gpt-4o' match 'openrouter/gpt-4o'.
+const MODEL_CONTEXT_WINDOWS = {
+  'claude': 200000,         // all claude models (opus, sonnet, haiku)
+  'gpt-4o': 128000,
+  'gpt-4-turbo': 128000,
+  'gpt-3.5': 16385,
+  'gemini-1.5-pro': 1000000,
+  'gemini-1.5-flash': 1000000,
+  'gemini-2': 1000000,
+  'llama-3.3': 128000,
+  'llama-3.1': 128000,
+  'mistral': 32000,
+  'deepseek': 64000,
+  'glm-5': 200000,
+  'glm-4': 128000,
+};
+
+function lookupContextWindow(model) {
+  if (!model) return null;
+  const m = model.toLowerCase();
+  for (const [key, size] of Object.entries(MODEL_CONTEXT_WINDOWS)) {
+    if (m.includes(key)) return size;
+  }
+  return null;
+}
+
 export async function startTelegramChannel(config) {
   const { token, allowedUserIds } = config.telegram;
 
@@ -160,11 +193,14 @@ export async function startTelegramChannel(config) {
   // --- Commands ---
 
   await bot.api.setMyCommands([
-    { command: 'new',   description: 'Reset the active slot (fresh session)' },
-    { command: 'usage', description: 'Token usage for the active slot' },
-    { command: 'stop',  description: 'Stop the running agent on the active slot' },
-    { command: 'slots', description: 'Show all slots and their status' },
-    { command: 'slot',  description: 'Switch or delete a slot: /slot 2 or /slot del 2' },
+    { command: 'new',     description: 'Reset the active slot (fresh session)' },
+    { command: 'usage',   description: 'Token usage for the active slot' },
+    { command: 'context', description: 'Estimated context size vs model limit' },
+    { command: 'stop',    description: 'Stop the running agent on the active slot' },
+    { command: 'slots',   description: 'Show all slots and their status' },
+    { command: 'version', description: 'Show Jarvis version' },
+    { command: 'update',  description: 'Update Jarvis to the latest version' },
+    { command: 'restart', description: 'Restart Jarvis' },
   ]);
 
   bot.command('usage', async (ctx) => {
@@ -197,6 +233,75 @@ export async function startTelegramChannel(config) {
     );
   });
 
+  bot.command('version', async (ctx) => {
+    const userId = ctx.from?.id;
+    if (!allowedUserIds.includes(userId)) return;
+    await ctx.reply(`Jarvis v${JARVIS_VERSION}`);
+  });
+
+  bot.command('update', async (ctx) => {
+    const userId = ctx.from?.id;
+    if (!allowedUserIds.includes(userId)) return;
+    await ctx.reply('Updating Jarvis...');
+    try {
+      const { stdout, stderr } = await execAsync('npm install -g @ducci/jarvis@latest', { timeout: 120000 });
+      const out = (stdout + stderr).trim().slice(-1000) || 'Done.';
+      await ctx.api.sendMessage(ctx.chat.id, `Update complete:\n${out}`);
+    } catch (e) {
+      await ctx.api.sendMessage(ctx.chat.id, `Update failed:\n${e.message.slice(0, 1000)}`);
+    }
+  });
+
+  bot.command('restart', async (ctx) => {
+    const userId = ctx.from?.id;
+    if (!allowedUserIds.includes(userId)) return;
+    await ctx.reply('Restarting Jarvis...');
+    // Fire and forget — process will exit before a response could be sent
+    setTimeout(() => execAsync('jarvis restart').catch(() => {}), 500);
+  });
+
+  bot.command('context', async (ctx) => {
+    const userId = ctx.from?.id;
+    if (!allowedUserIds.includes(userId)) return;
+
+    const chatId = ctx.chat.id;
+    const slot = getActiveSlot(chatId);
+    const sessionId = getSessionId(chatId, slot);
+    if (!sessionId) {
+      await ctx.reply('No active session. Send a message to start one.');
+      return;
+    }
+
+    const session = await loadSession(sessionId);
+    if (!session) {
+      await ctx.reply('Could not load session.');
+      return;
+    }
+
+    const msgCount = Math.max(0, session.messages.length - 1); // exclude system prompt
+    const estimatedTokens = Math.round(JSON.stringify(session.messages).length / 4);
+    const model = config.selectedModel || 'unknown';
+    const contextWindow = config.modelContextWindow || lookupContextWindow(model);
+
+    let lines = [
+      `<b>Context — Slot ${slot}</b>`,
+      `Model: <code>${escapeHtml(model)}</code>`,
+      `Messages in history: ${msgCount}`,
+      `Estimated tokens: ~${estimatedTokens.toLocaleString()}`,
+    ];
+
+    if (contextWindow) {
+      const pct = Math.round((estimatedTokens / contextWindow) * 100);
+      const bar = pct >= 90 ? '🔴' : pct >= 70 ? '🟡' : '🟢';
+      lines.push(`Model context window: ${contextWindow.toLocaleString()}`);
+      lines.push(`Usage: ${bar} ~${pct}%`);
+    } else {
+      lines.push(`Model context window: unknown`);
+    }
+
+    await ctx.reply(lines.join('\n'), { parse_mode: 'HTML' });
+  });
+
   bot.command('stop', async (ctx) => {
     const userId = ctx.from?.id;
     if (!allowedUserIds.includes(userId)) return;
@@ -234,11 +339,7 @@ export async function startTelegramChannel(config) {
     await ctx.reply(`New session started on slot ${slot}.`);
   });
 
-  bot.command('slots', async (ctx) => {
-    const userId = ctx.from?.id;
-    if (!allowedUserIds.includes(userId)) return;
-
-    const chatId = ctx.chat.id;
+  function buildSlotsDisplay(chatId) {
     const d = sessions[chatId];
     const activeSlot = getActiveSlot(chatId);
 
@@ -250,7 +351,10 @@ export async function startTelegramChannel(config) {
     }
 
     const slotNums = [...new Set(['1', ...Object.keys(slotsMap)])].sort((a, b) => Number(a) - Number(b));
+    const maxSlot = Math.max(...slotNums.map(Number));
+    const nextSlot = maxSlot + 1;
 
+    // Status text
     const lines = ['<b>Slots:</b>'];
     for (const sn of slotNums) {
       const n = Number(sn);
@@ -275,64 +379,93 @@ export async function startTelegramChannel(config) {
       }
       lines.push(`Slot ${n}: ${statusIcon}${activeMarker}`);
     }
-
-    // Always show one empty slot beyond the highest existing one
-    const maxSlot = Math.max(...slotNums.map(Number));
-    const nextSlot = maxSlot + 1;
     if (!isRunning.has(slotKey(chatId, nextSlot)) && !slotsMap[String(nextSlot)]) {
       lines.push(`Slot ${nextSlot}: ➕ leer`);
     }
 
-    await ctx.reply(lines.join('\n'), { parse_mode: 'HTML' });
-  });
+    // Inline keyboard
+    const kb = new InlineKeyboard();
+    for (const sn of slotNums) {
+      const n = Number(sn);
+      const sid = slotsMap[sn] ?? null;
+      const key = slotKey(chatId, n);
+      const running = isRunning.has(key);
+      if (n === activeSlot) {
+        kb.text(`✓ Slot ${n} (aktiv)`, `slots_noop`);
+      } else {
+        kb.text(`↩️ Slot ${n}`, `slots_switch_${n}`);
+      }
+      if (sid && !running) {
+        kb.text(`🗑️`, `slots_del_${n}`);
+      }
+      kb.row();
+    }
+    // Button for the next empty slot
+    kb.text(`➕ Slot ${nextSlot} (neu)`, `slots_switch_${nextSlot}`);
+
+    return { text: lines.join('\n'), keyboard: kb };
+  }
 
-  bot.command('slot', async (ctx) => {
+  bot.command('slots', async (ctx) => {
     const userId = ctx.from?.id;
     if (!allowedUserIds.includes(userId)) return;
 
     const chatId = ctx.chat.id;
-    const args = (ctx.match || '').trim().split(/\s+/).filter(Boolean);
+    const { text, keyboard } = buildSlotsDisplay(chatId);
+    await ctx.reply(text, { parse_mode: 'HTML', reply_markup: keyboard });
+  });
 
-    // /slot del N
-    if (args[0] === 'del') {
-      const n = parseInt(args[1], 10);
-      if (!n || n < 1) { await ctx.reply('Usage: /slot del <number>'); return; }
-      const key = slotKey(chatId, n);
-      if (isRunning.has(key) || pendingMessages.has(key)) {
-        await ctx.reply(`Slot ${n} ist gerade aktiv. Erst /stop, dann löschen.`);
-        return;
-      }
-      const oldSid = getSessionId(chatId, n);
-      if (oldSid) {
-        await appendTelegramChatLog(chatId, oldSid, 'SYSTEM', `--- /slot del ${n} ---`);
-      }
-      setSessionId(chatId, n, null);
-      pendingMessages.delete(key);
-      runStartTimes.delete(key);
-      if (getActiveSlot(chatId) === n) {
-        setActiveSlot(chatId, 1);
-        await ctx.reply(`Slot ${n} gelöscht. Zu Slot 1 gewechselt.`);
-      } else {
-        await ctx.reply(`Slot ${n} gelöscht.`);
-      }
-      return;
-    }
+  bot.callbackQuery(/^slots_switch_(\d+)$/, async (ctx) => {
+    const userId = ctx.from?.id;
+    if (!allowedUserIds.includes(userId)) { await ctx.answerCallbackQuery(); return; }
 
-    // /slot N — switch active slot
-    const n = parseInt(args[0], 10);
-    if (!n || n < 1) { await ctx.reply('Usage: /slot <number> oder /slot del <number>'); return; }
+    const chatId = ctx.chat.id;
+    const n = parseInt(ctx.match[1], 10);
     setActiveSlot(chatId, n);
-    const sid = getSessionId(chatId, n);
     const key = slotKey(chatId, n);
+    const sid = getSessionId(chatId, n);
     let status;
-    if (isRunning.has(key)) {
-      status = '🟢 läuft';
-    } else if (sid) {
-      status = '💬 bereit (vorhandene Session)';
-    } else {
-      status = '➕ leer (neue Session beim nächsten Message)';
+    if (isRunning.has(key)) status = '🟢 läuft';
+    else if (sid) status = '💬 bereit';
+    else status = '➕ leer (neue Session beim nächsten Message)';
+
+    const { text, keyboard } = buildSlotsDisplay(chatId);
+    await ctx.editMessageText(text, { parse_mode: 'HTML', reply_markup: keyboard });
+    await ctx.answerCallbackQuery(`Slot ${n} aktiv — ${status}`);
+  });
+
+  bot.callbackQuery(/^slots_del_(\d+)$/, async (ctx) => {
+    const userId = ctx.from?.id;
+    if (!allowedUserIds.includes(userId)) { await ctx.answerCallbackQuery(); return; }
+
+    const chatId = ctx.chat.id;
+    const n = parseInt(ctx.match[1], 10);
+    const key = slotKey(chatId, n);
+
+    if (isRunning.has(key) || pendingMessages.has(key)) {
+      await ctx.answerCallbackQuery(`Slot ${n} läuft gerade — erst /stop`);
+      return;
     }
-    await ctx.reply(`Slot ${n} ist jetzt aktiv. Status: ${status}`);
+
+    const oldSid = getSessionId(chatId, n);
+    if (oldSid) {
+      await appendTelegramChatLog(chatId, oldSid, 'SYSTEM', `--- slot del ${n} (via keyboard) ---`);
+    }
+    setSessionId(chatId, n, null);
+    pendingMessages.delete(key);
+    runStartTimes.delete(key);
+
+    if (getActiveSlot(chatId) === n) {
+      setActiveSlot(chatId, 1);
+    }
+
+    const { text, keyboard } = buildSlotsDisplay(chatId);
+    await ctx.editMessageText(text, { parse_mode: 'HTML', reply_markup: keyboard });
+    await ctx.answerCallbackQuery(`Slot ${n} gelöscht`);
+  });
+
+  bot.callbackQuery('slots_noop', async (ctx) => {
+    await ctx.answerCallbackQuery();
   });
 
   // Runs one or more batches until the pending queue is drained.

package/src/server/config.js

@@ -72,6 +72,7 @@ export function loadConfig() {
     maxIterations: settings.maxIterations || 20,
     maxHandoffs: settings.maxHandoffs || 3,
     contextWindow: settings.contextWindow || 100,
+    modelContextWindow: settings.modelContextWindow || null,
     port: settings.port || 18008,
     telegram: {
       token: process.env.TELEGRAM_BOT_TOKEN || null,

package/src/server/crons.js

@@ -45,6 +45,15 @@ export async function runCron(entry, config) {
   const failedApproaches = [];
   const checkpointState = {};
 
+  // Compact tool call representation for logs: "tool_name first_arg_value"
+  function compactToolCalls(toolCalls) {
+    return (toolCalls || []).map(tc => {
+      const firstVal = Object.values(tc.args || {})[0];
+      const argStr = firstVal !== undefined ? ' ' + String(firstVal).slice(0, 80) : '';
+      return `${tc.name}${argStr}`;
+    });
+  }
+
   try {
     while (true) {
       const runStartIndex = session.messages.length;
@@ -53,9 +62,25 @@ export async function runCron(entry, config) {
         run = await runAgentLoop(client, config, session, prepareMessages, usageAccum);
       } catch (e) {
         run = { status: 'error', response: e.message, logSummary: e.message, runToolCalls: [] };
+        await appendCronLog(entry.id, {
+          cronName: entry.name,
+          handoff: handoffCount + 1,
+          status: run.status,
+          logSummary: run.logSummary,
+          toolCalls: [],
+        }).catch(e => console.error(`[cron] log error: ${e.message}`));
         break;
       }
 
+      await appendCronLog(entry.id, {
+        cronName: entry.name,
+        handoff: handoffCount + 1,
+        status: run.status,
+        logSummary: run.logSummary,
+        ...(run.status !== 'checkpoint_reached' && { response: run.response }),
+        toolCalls: compactToolCalls(run.runToolCalls),
+      }).catch(e => console.error(`[cron] log error: ${e.message}`));
+
       if (run.status !== 'checkpoint_reached') break;
 
       if (run.checkpoint.failedApproaches?.length > 0) {
@@ -103,14 +128,6 @@ export async function runCron(entry, config) {
     run = { status: 'error', response: e.message, logSummary: e.message, runToolCalls: [] };
   }
 
-  // Log to cron JSONL
-  await appendCronLog(entry.id, {
-    cronName: entry.name,
-    status: run.status,
-    response: run.response,
-    logSummary: run.logSummary,
-  }).catch(e => console.error(`[cron] log error: ${e.message}`));
-
   // once: true — delete after firing
   if (entry.once) {
     try {

package/src/server/tools.js

@@ -571,12 +571,13 @@ const SEED_TOOLS = {
       type: 'function',
       function: {
         name: 'read_cron_log',
-        description: 'Read cron execution logs. Without id: returns recent runs across all crons (last 8 most recently active cron files, 5 entries each). With id: returns runs for that specific cron.',
+        description: 'Read cron execution logs. Without id: returns recent runs across all crons (last 8 most recently active cron files, 5 entries each). With id: returns runs for that specific cron. Each cron execution logs one entry per handoff. Use verbose:true to include tool call details for debugging.',
         parameters: {
           type: 'object',
           properties: {
             id: { type: 'string', description: 'The cron id. Omit to get an overview across all crons.' },
             limit: { type: 'number', description: 'Max entries to return when reading a specific cron. Defaults to 20.' },
+            verbose: { type: 'boolean', description: 'Include toolCalls array in each entry. Default false.' },
           },
           required: [],
         },
@@ -584,6 +585,12 @@ const SEED_TOOLS = {
     },
     code: `
       const logsDir = path.join(process.env.HOME, '.jarvis/logs');
+      const verbose = !!args.verbose;
+      function strip(entry) {
+        if (verbose) return entry;
+        const { toolCalls, ...rest } = entry;
+        return rest;
+      }
       if (!args.id) {
         const files = await fs.promises.readdir(logsDir).catch(() => []);
         const cronFiles = files.filter(f => f.startsWith('cron-') && f.endsWith('.jsonl'));
@@ -596,7 +603,7 @@ const SEED_TOOLS = {
         for (const { file } of withMtime.slice(0, 8)) {
           const content = await fs.promises.readFile(path.join(logsDir, file), 'utf8').catch(() => '');
           const lines = content.trim().split('\\n').filter(Boolean);
-          allEntries.push(...lines.slice(-5).map(line => JSON.parse(line)));
+          allEntries.push(...lines.slice(-5).map(line => strip(JSON.parse(line))));
         }
         allEntries.sort((a, b) => new Date(b.ts) - new Date(a.ts));
         return { status: 'ok', entries: allEntries };
@@ -604,7 +611,7 @@ const SEED_TOOLS = {
       const logFile = path.join(logsDir, 'cron-' + args.id + '.jsonl');
       const content = await fs.promises.readFile(logFile, 'utf8').catch(() => '');
       const lines = content.trim().split('\\n').filter(Boolean);
-      const entries = lines.slice(-(args.limit || 20)).map(line => JSON.parse(line));
+      const entries = lines.slice(-(args.limit || 20)).map(line => strip(JSON.parse(line)));
       return { status: 'ok', entries };
     `,
   },