@ducci/jarvis 1.0.38 → 1.0.40

package/src/server/agent.js

@@ -4,6 +4,7 @@ import { loadSystemPrompt, resolveSystemPrompt } from './config.js';
 import { loadSession, saveSession, createSession } from './sessions.js';
 import { loadTools, getToolDefinitions, executeTool } from './tools.js';
 import { appendLog } from './logging.js';
+import * as cronScheduler from './cron-scheduler.js';
 import chalk from 'chalk';
 
 const FORMAT_NUDGE = 'Your previous response was not valid JSON. Respond only with the required JSON object: {"response": "...", "logSummary": "..."}';
@@ -102,7 +103,7 @@ function hasConsecutiveModelErrors(messages) {
  * Runs a single agent loop up to maxIterations.
  * Returns { iteration, response, logSummary, status, runToolCalls, checkpoint }.
  */
-async function runAgentLoop(client, config, session, prepareMessages, usageAccum) {
+export async function runAgentLoop(client, config, session, prepareMessages, usageAccum) {
   let tools = await loadTools();
   let toolDefs = getToolDefinitions(tools);
   let iteration = 0;
@@ -169,7 +170,6 @@ async function runAgentLoop(client, config, session, prepareMessages, usageAccum
         })),
       });
 
-      let toolsModified = false;
       let stderrErrorInIteration = false;
       for (const toolCall of assistantMessage.tool_calls) {
         const toolName = toolCall.function.name;
@@ -201,10 +201,6 @@ async function runAgentLoop(client, config, session, prepareMessages, usageAccum
           toolStatus = 'error';
         }
 
-        if (toolName === 'save_tool' && toolStatus === 'ok') {
-          toolsModified = true;
-        }
-
         const resultObj = typeof result === 'object' && result !== null ? result : null;
         const toolFailed = toolStatus === 'error' || (resultObj && resultObj.status === 'error');
         if (toolFailed) {
@@ -232,6 +228,20 @@ async function runAgentLoop(client, config, session, prepareMessages, usageAccum
           content: sessionContent,
         });
 
+        // Dynamic cron scheduling — update the in-memory scheduler immediately
+        // so the cron is active without requiring a server restart.
+        if (toolStatus === 'ok') {
+          try {
+            if (toolName === 'create_cron') {
+              const cronEntry = JSON.parse(resultStr)?.cron;
+              if (cronEntry) cronScheduler.schedule(cronEntry);
+            } else if (toolName === 'delete_cron') {
+              const id = JSON.parse(resultStr)?.id;
+              if (id) cronScheduler.unschedule(id);
+            }
+          } catch { /* ignore parse errors */ }
+        }
+
         const callKey = `${toolName}|${JSON.stringify(toolArgs)}|${resultStr}`;
         loopTracker.set(callKey, (loopTracker.get(callKey) || 0) + 1);
       }
@@ -265,12 +275,6 @@ async function runAgentLoop(client, config, session, prepareMessages, usageAccum
         });
       }
 
-      // Reload tools if any were created/updated this iteration
-      if (toolsModified) {
-        tools = await loadTools();
-        toolDefs = getToolDefinitions(tools);
-      }
-
       continue;
     }
 
@@ -454,11 +458,32 @@ async function runAgentLoop(client, config, session, prepareMessages, usageAccum
   return { iteration, response, logSummary, status, runToolCalls, checkpoint: null };
 }
 
+/**
+ * Acquires the session lock and runs fn() inside it.
+ * Used by the cron runner to safely write to a session that may also
+ * receive concurrent user messages.
+ */
+export async function withSessionLock(sessionId, fn) {
+  const previous = sessionQueues.get(sessionId) ?? Promise.resolve();
+  let releaseLock;
+  const current = new Promise(resolve => { releaseLock = resolve; });
+  sessionQueues.set(sessionId, current);
+  await previous;
+  try {
+    return await fn();
+  } finally {
+    releaseLock();
+    if (sessionQueues.get(sessionId) === current) {
+      sessionQueues.delete(sessionId);
+    }
+  }
+}
+
 /**
  * Main entry point: handles a single POST /api/chat request.
  * Manages the handoff loop across multiple agent runs.
  */
-export async function handleChat(config, requestSessionId, userMessage) {
+export async function handleChat(config, requestSessionId, userMessage, attachments = []) {
   const sessionId = requestSessionId || crypto.randomUUID();
 
   // Serialize concurrent requests for the same session. Each request registers
@@ -472,7 +497,7 @@ export async function handleChat(config, requestSessionId, userMessage) {
   await previous;
 
   try {
-    return await _runHandleChat(config, sessionId, userMessage);
+    return await _runHandleChat(config, sessionId, userMessage, attachments);
   } finally {
     releaseLock();
     // Clean up only if no one else has queued behind us
@@ -486,7 +511,7 @@ export async function handleChat(config, requestSessionId, userMessage) {
  * The actual chat logic, extracted so handleChat can wrap it cleanly with the
  * session lock.
  */
-async function _runHandleChat(config, sessionId, userMessage) {
+async function _runHandleChat(config, sessionId, userMessage, attachments = []) {
   const client = createClient(config);
 
   const systemPromptTemplate = loadSystemPrompt();
@@ -520,21 +545,36 @@ async function _runHandleChat(config, sessionId, userMessage) {
     userMessageWithContext += note;
   }
 
-  // Append user message and reset handoff state
-  session.messages.push({ role: 'user', content: userMessageWithContext });
+  // Append user message and reset handoff state.
+  // If attachments (e.g. images) are present, build a multimodal content array.
+  let userContent;
+  if (attachments && attachments.length > 0) {
+    userContent = [
+      ...attachments.map(a => ({ type: 'image_url', image_url: { url: a.url } })),
+      { type: 'text', text: userMessageWithContext },
+    ];
+  } else {
+    userContent = userMessageWithContext;
+  }
+  session.messages.push({ role: 'user', content: userContent });
   session.metadata.handoffCount = 0;
   session.metadata.failedApproaches = [];
   session.metadata.lastCheckpointRemaining = null;
   session.metadata.checkpointState = {};
 
-  // Resolves {{user_info}} in system prompt at runtime (never persisted)
+  // Resolves {{user_info}} in system prompt at runtime (never persisted).
+  // Applies a sliding window: always includes the system prompt (messages[0])
+  // plus the most recent contextWindow messages, so long sessions don't overflow
+  // the model's context. Full history is always preserved on disk.
   function prepareMessages(messages) {
-    return messages.map((msg, i) => {
+    const resolved = messages.map((msg, i) => {
       if (i === 0 && msg.role === 'system') {
         return { ...msg, content: resolveSystemPrompt(msg.content, sessionId) };
       }
       return msg;
     });
+    if (resolved.length <= config.contextWindow + 1) return resolved;
+    return [resolved[0], ...resolved.slice(-(config.contextWindow))];
   }
 
   const allToolCalls = [];

package/src/server/app.js

@@ -2,10 +2,11 @@ import express from 'express';
 import path from 'path';
 import chalk from 'chalk';
 import { fileURLToPath } from 'url';
-import { realpathSync } from 'fs';
-import { loadConfig, ensureDirectories } from './config.js';
+import fs, { realpathSync, existsSync, writeFileSync } from 'fs';
+import { loadConfig, ensureDirectories, PATHS } from './config.js';
 import { seedTools } from './tools.js';
 import { handleChat } from './agent.js';
+import { initCrons } from './crons.js';
 import { startTelegramChannel } from '../channels/telegram/index.js';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -58,6 +59,125 @@ app.use((req, res, next) => {
   }
 });
 
+const DEFAULT_IDENTITY = `# Identity
+
+You are Jarvis, a fully autonomous agent running on a local server. You have access to tools and can execute shell commands on the machine you run on.
+
+Be concise and direct in your responses. Avoid unnecessary filler. When a task is done, say so clearly.
+`;
+
+function seedIdentity() {
+  if (!existsSync(PATHS.identityFile)) {
+    writeFileSync(PATHS.identityFile, DEFAULT_IDENTITY, 'utf8');
+    console.log('Created default identity.md');
+  }
+}
+
+const EXAMPLE_SKILL_MD = `---
+name: add-two-integers
+description: Adds two integer numbers by running a Node.js script
+---
+
+# Add Two Integers
+
+Use this skill when asked to add two integer numbers.
+
+## How to use
+
+Run the bundled script via \`exec\` with two integer arguments:
+
+\`\`\`sh
+node ~/.jarvis/data/skills/add-two-integers/add.js <a> <b>
+\`\`\`
+
+Example:
+
+\`\`\`sh
+node ~/.jarvis/data/skills/add-two-integers/add.js 3 7
+# Output: 10
+\`\`\`
+
+Both arguments must be integers. The script exits with code 1 and prints a usage error if either argument is missing or not a valid integer.
+`;
+
+const EXAMPLE_SKILL_JS = `const a = parseInt(process.argv[2], 10);
+const b = parseInt(process.argv[3], 10);
+
+if (isNaN(a) || isNaN(b)) {
+  console.error('Usage: node add.js <integer_a> <integer_b>');
+  process.exit(1);
+}
+
+console.log(a + b);
+`;
+
+const MANAGE_SKILL_MD = `---
+name: manage-skill
+description: Create, edit, or delete a skill in ~/.jarvis/data/skills/. Use this when the user asks to add a new skill, update an existing skill, or remove a skill.
+---
+
+# Manage Skill
+
+Use this skill when the user asks to create, list, edit, or delete a skill.
+
+## What makes a good skill
+
+- A skill describes a **workflow or approach**, not a single command
+- The name is specific and lowercase with hyphens (e.g. \`scan-open-ports\`, not \`scanning\`)
+- The description (frontmatter) is the **only signal the agent has to decide whether to load the skill**. Write it so the agent reliably recognises when this skill applies: be specific about the task type, not just the topic, and include when to use it. Bad: "Manages ports." Good: "Scan a target host for open ports using nmap and return a structured report. Use this when the user asks to scan ports or check what services are running on a host."
+- Instructions are written for the agent, not the user — be explicit about which tools to use
+- If the skill needs a script, bundle it in the same folder and reference it by absolute path using \`~/.jarvis/data/skills/<name>/script.js\`
+- Prefer \`write_file\` over \`exec+echo\` for writing any file
+
+## Folder structure
+
+\`\`\`
+~/.jarvis/data/skills/<name>/
+  skill.md       ← required
+  *.js / *.sh    ← optional bundled scripts
+\`\`\`
+
+## Frontmatter format
+
+\`\`\`yaml
+---
+name: skill-name
+description: Description that reliably tells the agent when to use this skill
+---
+\`\`\`
+
+## Create a skill
+
+1. Create the folder: \`exec\` → \`mkdir -p ~/.jarvis/data/skills/<name>\`
+2. Write \`skill.md\` with frontmatter + instructions using \`write_file\`
+3. If scripts are needed, write them with \`write_file\` into the same folder
+
+## Edit a skill
+
+1. Read current content: \`exec\` → \`cat ~/.jarvis/data/skills/<name>/skill.md\`
+2. Overwrite with updated content using \`write_file\`
+
+## Delete a skill
+
+1. Confirm the skill name with the user before deleting
+2. \`exec\` → \`rm -rf ~/.jarvis/data/skills/<name>\`
+`;
+
+function seedSkills() {
+  const skills = [
+    { dir: 'add-two-integers', files: { 'skill.md': EXAMPLE_SKILL_MD, 'add.js': EXAMPLE_SKILL_JS } },
+    { dir: 'manage-skill', files: { 'skill.md': MANAGE_SKILL_MD } },
+  ];
+  for (const skill of skills) {
+    const skillDir = path.join(PATHS.skillsDir, skill.dir);
+    fs.mkdirSync(skillDir, { recursive: true });
+    for (const [filename, content] of Object.entries(skill.files)) {
+      const filePath = path.join(skillDir, filename);
+      if (!existsSync(filePath)) writeFileSync(filePath, content, 'utf8');
+    }
+  }
+}
+
 function startServer() {
   let config;
   try {
@@ -69,6 +189,9 @@ function startServer() {
 
   ensureDirectories();
   seedTools();
+  seedIdentity();
+  seedSkills();
+  initCrons(config);
 
   app.locals.config = config;
 

package/src/server/config.js

@@ -19,6 +19,9 @@ export const PATHS = {
   toolsFile: path.join(JARVIS_DIR, 'data', 'tools', 'tools.json'),
   logsDir: path.join(JARVIS_DIR, 'logs'),
   userInfoFile: path.join(JARVIS_DIR, 'data', 'user-info.json'),
+  identityFile: path.join(JARVIS_DIR, 'data', 'identity.md'),
+  skillsDir: path.join(JARVIS_DIR, 'data', 'skills'),
+  cronsFile: path.join(JARVIS_DIR, 'data', 'crons.json'),
   systemPromptFile: path.join(__dirname, '..', '..', 'docs', 'system-prompt.md'),
 };
 
@@ -54,6 +57,7 @@ export function loadConfig() {
     fallbackModel: settings.fallbackModel || (provider === 'anthropic' ? 'claude-haiku-4-5-20251001' : 'openrouter/free'),
     maxIterations: settings.maxIterations || 10,
     maxHandoffs: settings.maxHandoffs || 5,
+    contextWindow: settings.contextWindow || 100,
     port: settings.port || 18008,
     telegram: {
       token: process.env.TELEGRAM_BOT_TOKEN || null,
@@ -69,7 +73,43 @@ export function loadSystemPrompt() {
   return match[1].trim();
 }
 
+function parseSkillFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return null;
+  const meta = {};
+  for (const line of match[1].split('\n')) {
+    const [key, ...rest] = line.split(':');
+    if (key && rest.length) meta[key.trim()] = rest.join(':').trim();
+  }
+  return meta;
+}
+
 export function resolveSystemPrompt(promptTemplate, sessionId) {
+  let identity = '';
+  try {
+    identity = fs.readFileSync(PATHS.identityFile, 'utf8').trim();
+  } catch {
+    // File doesn't exist yet
+  }
+
+  let skillsList = '(none)';
+  try {
+    const entries = fs.readdirSync(PATHS.skillsDir, { withFileTypes: true });
+    const skills = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const skillFile = path.join(PATHS.skillsDir, entry.name, 'skill.md');
+      try {
+        const content = fs.readFileSync(skillFile, 'utf8');
+        const meta = parseSkillFrontmatter(content);
+        if (meta?.name && meta?.description) {
+          skills.push(`- ${meta.name}: ${meta.description}`);
+        }
+      } catch { /* skip malformed skills */ }
+    }
+    if (skills.length > 0) skillsList = skills.join('\n');
+  } catch { /* skills dir doesn't exist yet */ }
+
   let userInfo = '(none yet)';
   try {
     const raw = fs.readFileSync(PATHS.userInfoFile, 'utf8');
@@ -80,7 +120,10 @@ export function resolveSystemPrompt(promptTemplate, sessionId) {
   } catch {
     // File doesn't exist yet
   }
+
   return promptTemplate
+    .replace('{{identity}}', identity)
+    .replace('{{skills}}', skillsList)
     .replace('{{session_id}}', sessionId || 'unknown')
     .replace('{{user_info}}', userInfo);
 }

package/src/server/cron-scheduler.js

@@ -0,0 +1,35 @@
+import cron from 'node-cron';
+
+// Maps cron id -> active node-cron task
+const tasks = new Map();
+
+let _runCron = null;
+let _config = null;
+
+export function init(runCronFn, config) {
+  _runCron = runCronFn;
+  _config = config;
+}
+
+export function schedule(entry) {
+  // Stop existing task if rescheduling
+  if (tasks.has(entry.id)) {
+    tasks.get(entry.id).stop();
+  }
+  const task = cron.schedule(entry.schedule, () => {
+    _runCron(entry, _config).catch(e => {
+      console.error(`[cron] Error running "${entry.name}": ${e.message}`);
+    });
+  });
+  tasks.set(entry.id, task);
+  console.log(`[cron] scheduled "${entry.name}" (${entry.schedule})`);
+}
+
+export function unschedule(id) {
+  const task = tasks.get(id);
+  if (task) {
+    task.stop();
+    tasks.delete(id);
+    console.log(`[cron] unscheduled id=${id}`);
+  }
+}

package/src/server/crons.js

@@ -0,0 +1,106 @@
+import fs from 'fs';
+import path from 'path';
+import { runAgentLoop, withSessionLock } from './agent.js';
+import { createClient } from './provider.js';
+import { loadSystemPrompt, resolveSystemPrompt, PATHS } from './config.js';
+import { createSession, loadSession, saveSession } from './sessions.js';
+import * as cronScheduler from './cron-scheduler.js';
+import { load as loadTelegramSessions } from '../channels/telegram/sessions.js';
+
+function loadCrons() {
+  try {
+    return JSON.parse(fs.readFileSync(PATHS.cronsFile, 'utf8'));
+  } catch {
+    return [];
+  }
+}
+
+async function appendCronLog(cronId, entry) {
+  const logFile = path.join(PATHS.logsDir, `cron-${cronId}.jsonl`);
+  const line = JSON.stringify({ ts: new Date().toISOString(), ...entry }) + '\n';
+  await fs.promises.appendFile(logFile, line, 'utf8');
+}
+
+async function writeSyntheticMessageToTelegramSession(entry, response, config) {
+  const chatId = config.telegram?.allowedUserIds?.[0];
+  if (!chatId) return;
+
+  const sessions = loadTelegramSessions();
+  const sessionId = sessions[chatId];
+  if (!sessionId) return;
+
+  const ts = new Date().toISOString().slice(0, 16).replace('T', ' ');
+  const syntheticMessage = `[Cron "${entry.name}" | ${ts}] ${response}`;
+
+  await withSessionLock(sessionId, async () => {
+    const session = await loadSession(sessionId);
+    if (!session) return;
+    session.messages.push({ role: 'assistant', content: syntheticMessage });
+    await saveSession(sessionId, session);
+  });
+}
+
+export async function runCron(entry, config) {
+  console.log(`[cron] running "${entry.name}"`);
+
+  const systemPromptTemplate = loadSystemPrompt();
+  const session = createSession(systemPromptTemplate);
+  session.messages.push({ role: 'user', content: entry.prompt });
+
+  const client = createClient(config);
+  const usageAccum = { prompt: 0, completion: 0, cacheRead: 0, cacheCreation: 0 };
+
+  function prepareMessages(messages) {
+    return messages.map((msg, i) => {
+      if (i === 0 && msg.role === 'system') {
+        return { ...msg, content: resolveSystemPrompt(msg.content, `cron-${entry.id}`) };
+      }
+      return msg;
+    });
+  }
+
+  let run;
+  try {
+    run = await runAgentLoop(client, config, session, prepareMessages, usageAccum);
+  } catch (e) {
+    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}`));
+
+  // Write synthetic message to user's Telegram session
+  await writeSyntheticMessageToTelegramSession(entry, run.response, config).catch(e => {
+    console.error(`[cron] telegram session write error: ${e.message}`);
+  });
+
+  // once: true — delete after firing
+  if (entry.once) {
+    try {
+      const crons = loadCrons().filter(c => c.id !== entry.id);
+      fs.writeFileSync(PATHS.cronsFile, JSON.stringify(crons, null, 2), 'utf8');
+      cronScheduler.unschedule(entry.id);
+    } catch (e) {
+      console.error(`[cron] cleanup error: ${e.message}`);
+    }
+  }
+}
+
+export function initCrons(config) {
+  cronScheduler.init(runCron, config);
+
+  const crons = loadCrons();
+  for (const entry of crons) {
+    try {
+      cronScheduler.schedule(entry);
+    } catch (e) {
+      console.error(`[cron] failed to schedule "${entry.name}": ${e.message}`);
+    }
+  }
+  console.log(`[cron] initialized ${crons.length} cron(s)`);
+}