@ducci/jarvis 1.0.79 → 1.0.81

package/package.json

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

package/src/channels/telegram/index.js

@@ -1,5 +1,11 @@
 import fs from 'fs';
 import path from 'path';
+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';
@@ -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,10 +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: '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) => {
@@ -196,6 +233,79 @@ 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 totalMessages = Math.max(0, session.messages.length - 1); // exclude system prompt
+    const windowed = session.messages.length <= config.contextWindow + 1
+      ? session.messages
+      : [session.messages[0], ...session.messages.slice(-config.contextWindow)];
+    const inContext = Math.max(0, windowed.length - 1);
+    const estimatedTokens = Math.round(JSON.stringify(windowed).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 on disk: ${totalMessages} | in context: ${inContext}`,
+      `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;

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 };
     `,
   },