@ducci/jarvis 1.0.47 → 1.0.49

package/docs/system-prompt.md

@@ -45,7 +45,7 @@ There are two types of responses depending on whether you need to use tools:
   "logSummary": "A concise explanation of what you did and why, written for a human reading the logs."
 }
 
-The `response` value must be a string — never an array or object. Use HTML formatting tags for readability: <b>bold</b>, <i>italic</i>, <code>inline code</code>, <pre>code blocks</pre>, <blockquote>quotes</blockquote>. Never use Markdown formatting (no **, __, `, or ```). If you need to present structured data (e.g. a list of items), format it as text within the string value.
+The `response` value must be a string — never an array or object. Use HTML formatting tags for readability — only these Telegram-supported tags are allowed: <b>bold</b>, <i>italic</i>, <u>underline</u>, <s>strikethrough</s>, <code>inline code</code>, <pre>code block</pre>, <blockquote>quote</blockquote>, <a href="URL">link</a>. For line breaks use actual newlines (\n), never <br>. Never use Markdown formatting (no **, __, `, or ```). If you need to present structured data (e.g. a list of items), format it as text within the string value.
 
 Never include markdown code fences, preamble, or any text outside this JSON object. If you cannot complete a task, explain why in the `response` field — still as valid JSON.
 

package/package.json

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

package/src/channels/telegram/index.js

@@ -9,6 +9,8 @@ import { load, save } from './sessions.js';
 
 async function sendMessage(api, chatId, text, sessionId) {
   const MAX_TG = 4096;
+  // Telegram HTML mode does not support <br> — replace with newlines before sending
+  text = text.replace(/<br\s*\/?>/gi, '\n');
   const chunks = [];
   for (let i = 0; i < text.length; i += MAX_TG) {
     chunks.push(text.slice(i, i + MAX_TG));

package/src/scripts/onboarding.js

@@ -3,9 +3,25 @@
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
+import { spawnSync } from 'child_process';
+import { createRequire } from 'module';
 import inquirer from 'inquirer';
 import chalk from 'chalk';
 
+// Resolve pm2 CLI from local node_modules so it works even when pm2 is not in PATH
+// (e.g. when Node is managed by NVM and the shell is not initialised with it).
+const _require = createRequire(import.meta.url);
+let PM2_BIN;
+try {
+  PM2_BIN = _require.resolve('pm2/bin/pm2');
+} catch {
+  PM2_BIN = null; // will fall back gracefully
+}
+function pm2(...args) {
+  if (!PM2_BIN) return { status: 1, error: new Error('pm2 binary not found') };
+  return spawnSync(process.execPath, [PM2_BIN, ...args], { stdio: 'inherit' });
+}
+
 const jarvisDir = path.join(os.homedir(), '.jarvis');
 const envFile = path.join(jarvisDir, '.env');
 const configDir = path.join(jarvisDir, 'data', 'config');
@@ -420,6 +436,37 @@ async function run() {
     }
   }
 
+  // --- LOG ROTATION STEP ---
+  const logrotateModuleDir = path.join(os.homedir(), '.pm2', 'modules', 'pm2-logrotate');
+  const logrotateInstalled = fs.existsSync(logrotateModuleDir);
+
+  if (logrotateInstalled) {
+    console.log(chalk.green('pm2-logrotate is already installed — server.log will be rotated automatically.'));
+  } else {
+    const { setupLogrotate } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'setupLogrotate',
+        message: 'Install pm2-logrotate to prevent server.log from growing indefinitely?',
+        default: true,
+      }
+    ]);
+
+    if (setupLogrotate) {
+      console.log(chalk.blue('Installing pm2-logrotate...'));
+      const install = pm2('install', 'pm2-logrotate');
+      if (install.status !== 0) {
+        console.log(chalk.yellow('Installation failed — try running `pm2 install pm2-logrotate` manually.'));
+      } else {
+        pm2('set', 'pm2-logrotate:max_size', '10M');
+        pm2('set', 'pm2-logrotate:retain', '5');
+        pm2('set', 'pm2-logrotate:compress', 'true');
+        pm2('set', 'pm2-logrotate:rotateInterval', '0 0 * * *');
+        console.log(chalk.green('pm2-logrotate installed: 10 MB max, 5 rotated files kept, daily rotation.'));
+      }
+    }
+  }
+
   console.log(chalk.green.bold('\nSetup complete!'));
 }
 

package/src/server/agent.js

@@ -105,6 +105,72 @@ function hasConsecutiveModelErrors(messages) {
   );
 }
 
+/**
+ * Runs a subagent in its own isolated session for a single self-contained task.
+ * Called when the parent agent invokes the spawn_subagent tool.
+ */
+async function runSubagent(client, config, args, parentSessionId) {
+  const subSessionId = `sub-${crypto.randomUUID()}`;
+  const systemPromptTemplate = loadSystemPrompt();
+  const subSession = createSession(systemPromptTemplate);
+
+  let userContent = args.prompt;
+  if (args.context) {
+    userContent = `[Context: ${args.context}]\n\n${args.prompt}`;
+  }
+  subSession.messages.push({ role: 'user', content: userContent });
+
+  const subConfig = {
+    ...config,
+    excludeTools: ['spawn_subagent'],
+    maxIterations: args.maxIterations || config.maxIterations,
+    _sessionId: subSessionId,
+  };
+
+  const usageAccum = { prompt: 0, completion: 0, cacheRead: 0, cacheCreation: 0 };
+
+  function prepareMessages(messages) {
+    const resolved = messages.map((msg, i) => {
+      if (i === 0 && msg.role === 'system') {
+        return { ...msg, content: resolveSystemPrompt(msg.content, subSessionId) };
+      }
+      return msg;
+    });
+    if (resolved.length <= subConfig.contextWindow + 1) return resolved;
+    return [resolved[0], ...resolved.slice(-(subConfig.contextWindow))];
+  }
+
+  const run = await runAgentLoop(client, subConfig, subSession, prepareMessages, usageAccum);
+
+  await appendLog(subSessionId, {
+    iteration: run.iteration,
+    model: config.selectedModel,
+    userInput: args.prompt,
+    toolCalls: run.runToolCalls,
+    response: run.response,
+    logSummary: run.logSummary,
+    status: run.status,
+    parentSessionId: parentSessionId || null,
+    label: args.label || null,
+    tokenUsage: { ...usageAccum },
+  });
+
+  subSession.metadata.tokenUsage = { ...usageAccum };
+
+  try {
+    await saveSession(subSessionId, subSession);
+  } catch (e) {
+    console.error(`Failed to save subagent session ${subSessionId}:`, e);
+  }
+
+  return {
+    status: 'ok',
+    response: run.response,
+    runStatus: run.status,
+    sessionId: subSessionId,
+  };
+}
+
 /**
  * Runs a single agent loop up to maxIterations.
  * Returns { iteration, response, logSummary, status, runToolCalls, checkpoint }.
@@ -112,6 +178,9 @@ function hasConsecutiveModelErrors(messages) {
 export async function runAgentLoop(client, config, session, prepareMessages, usageAccum) {
   let tools = await loadTools();
   let toolDefs = getToolDefinitions(tools);
+  if (config.excludeTools?.length) {
+    toolDefs = toolDefs.filter(t => !config.excludeTools.includes(t.function?.name));
+  }
   let iteration = 0;
   const runToolCalls = [];
   const loopTracker = new Map();
@@ -162,7 +231,7 @@ export async function runAgentLoop(client, config, session, prepareMessages, usa
 
     const assistantMessage = modelResult.choices[0].message;
 
-    // Tool calls present — execute serially and continue loop
+    // Tool calls present — execute in parallel, then process results in order
     if (assistantMessage.tool_calls && assistantMessage.tool_calls.length > 0) {
       session.messages.push({
         role: 'assistant',
@@ -176,17 +245,42 @@ export async function runAgentLoop(client, config, session, prepareMessages, usa
         })),
       });
 
-      let stderrErrorInIteration = false;
-      for (const toolCall of assistantMessage.tool_calls) {
-        const toolName = toolCall.function.name;
-        let toolArgs;
-        let argParseError = null;
-        try {
-          toolArgs = JSON.parse(toolCall.function.arguments || '{}');
-        } catch (e) {
-          argParseError = e;
-        }
+      // Execute all tool calls concurrently; session mutations happen serially below.
+      const toolResults = await Promise.all(
+        assistantMessage.tool_calls.map(async (toolCall) => {
+          const toolName = toolCall.function.name;
+          let toolArgs;
+          let argParseError = null;
+          try {
+            toolArgs = JSON.parse(toolCall.function.arguments || '{}');
+          } catch (e) {
+            argParseError = e;
+          }
 
+          if (argParseError) {
+            return { toolCall, toolName, toolArgs: {}, argParseError, result: null, toolStatus: 'error' };
+          }
+
+          let result;
+          let toolStatus = 'ok';
+          try {
+            if (toolName === 'spawn_subagent') {
+              result = await runSubagent(client, config, toolArgs, config._sessionId);
+            } else {
+              result = await executeTool(tools, toolName, toolArgs);
+            }
+          } catch (e) {
+            result = { status: 'error', error: e.message };
+            toolStatus = 'error';
+          }
+
+          return { toolCall, toolName, toolArgs, argParseError: null, result, toolStatus };
+        })
+      );
+
+      // Process results serially to preserve message order and update trackers.
+      let stderrErrorInIteration = false;
+      for (const { toolCall, toolName, toolArgs, argParseError, result, toolStatus } of toolResults) {
         if (argParseError) {
           const errorContent = JSON.stringify({
             status: 'error',
@@ -198,15 +292,6 @@ export async function runAgentLoop(client, config, session, prepareMessages, usa
           continue;
         }
 
-        let result;
-        let toolStatus = 'ok';
-        try {
-          result = await executeTool(tools, toolName, toolArgs);
-        } catch (e) {
-          result = { status: 'error', error: e.message };
-          toolStatus = 'error';
-        }
-
         const resultObj = typeof result === 'object' && result !== null ? result : null;
         const toolFailed = toolStatus === 'error' || (resultObj && resultObj.status === 'error');
         if (toolFailed) {
@@ -620,7 +705,7 @@ async function _runHandleChat(config, sessionId, userMessage, attachments = [])
       }
 
       const runStartIndex = session.messages.length;
-      const run = await runAgentLoop(client, config, session, prepareMessages, usageAccum);
+      const run = await runAgentLoop(client, { ...config, _sessionId: sessionId }, session, prepareMessages, usageAccum);
       allToolCalls.push(...run.runToolCalls);
 
       if (run.status !== 'checkpoint_reached') {

package/src/server/logging.js

@@ -11,7 +11,6 @@ export async function appendLog(sessionId, entry) {
   // Console output for better visibility
   const statusColor = entry.status === 'ok' ? chalk.green : chalk.red;
   console.log(
-    `[${chalk.dim(new Date().toLocaleTimeString())}] ` +
     `${chalk.blue('Session')}: ${chalk.dim(sessionId.slice(0, 8))} | ` +
     `${chalk.yellow('Iter')}: ${entry.iteration} | ` +
     `${chalk.cyan('Status')}: ${statusColor(entry.status)} | ` +

package/src/server/start.js

@@ -1,3 +1,11 @@
+// Prefix every console.log/error line with a date+time stamp so all output
+// (agent, cron, telegram, tools, etc.) is consistently timestamped in server.log.
+const _log = console.log.bind(console);
+const _err = console.error.bind(console);
+const ts = () => new Date().toISOString().replace('T', ' ').slice(0, 19);
+console.log = (...args) => _log(`[${ts()}]`, ...args);
+console.error = (...args) => _err(`[${ts()}]`, ...args);
+
 import { startServer } from './app.js';
 
 startServer();

package/src/server/tools.js

@@ -584,6 +584,38 @@ const SEED_TOOLS = {
       return { status: 'ok', entries };
     `,
   },
+  spawn_subagent: {
+    definition: {
+      type: 'function',
+      function: {
+        name: 'spawn_subagent',
+        description: 'Spawn an independent subagent to handle a single subtask in its own isolated context and session. Use this when processing many similar items (e.g. emails, files, URLs) where doing them serially in the same context would overflow. Each subagent runs a full agent loop with access to all tools and returns its final response. Multiple spawn_subagent calls in a single response run in parallel. The subagent has no access to the current conversation — the prompt must be fully self-contained. Do not instruct subagents to use send_telegram_message; collect their results and notify the user yourself.',
+        parameters: {
+          type: 'object',
+          properties: {
+            prompt: {
+              type: 'string',
+              description: 'The self-contained task for the subagent. Must include all necessary context — the subagent has no access to the current conversation history.',
+            },
+            context: {
+              type: 'string',
+              description: 'Optional extra context to prepend to the prompt (e.g. the item to process, such as an email body or file path).',
+            },
+            label: {
+              type: 'string',
+              description: 'Optional short label for this subagent, used in logging (e.g. "email-42", "file-scan-/tmp/foo.txt").',
+            },
+            maxIterations: {
+              type: 'number',
+              description: 'Optional cap on the number of iterations the subagent may use. Defaults to the global maxIterations setting. Use a lower value (e.g. 5) for simple subtasks in bulk processing.',
+            },
+          },
+          required: ['prompt'],
+        },
+      },
+    },
+    code: `return { status: 'error', error: 'spawn_subagent is a native tool handled by the agent runtime.' };`,
+  },
   read_skill: {
     definition: {
       type: 'function',