@ducci/jarvis 1.0.17 → 1.0.19

package/docs/system-prompt.md

@@ -53,6 +53,14 @@ The `exec` tool runs real shell commands on the server. Use it responsibly:
 - **Prefer targeted reads.** Use `grep`, `head`, or `tail` instead of `cat` on files you haven't seen before. Large file output is truncated anyway — a targeted command gives you better signal.
 - **Avoid commands with unbounded runtime.** If a command could run indefinitely or scan an unknown-size tree, scope it first.
 
+## Tool Creation
+
+When building a custom tool with `save_tool`:
+
+- **Prefer npm packages** over reimplementing functionality from scratch. If a well-known package exists for the task (e.g. an API SDK, a parser, a utility library), use it.
+- **Installing an npm package**: use the `npm_install` tool — it handles the correct install directory automatically. Then create the tool with `save_tool`. The tool code can `require('<package-name>')` directly.
+- **Available bindings in tool code**: `args`, `fs`, `path`, `process`, `require`, `__jarvisDir` (absolute path to the jarvis server directory).
+
 ## logSummary Guidelines
 
 The `logSummary` is written for a human observer, not for the user. It must:

package/package.json

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

package/src/channels/telegram/index.js

@@ -45,20 +45,36 @@ export async function startTelegramChannel(config) {
       ctx.api.sendChatAction(chatId, 'typing').catch(() => {});
     }, 4000);
 
+    let result;
     try {
-      const result = await handleChat(config, sessionId, ctx.message.text);
+      result = await handleChat(config, sessionId, ctx.message.text);
+    } catch (e) {
+      console.error(`[telegram] agent error chat_id=${chatId}: ${e.message}`);
+      await ctx.reply('Sorry, something went wrong. Please try again.');
+      clearInterval(typingInterval);
+      return;
+    }
 
-      // 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)}`);
-      }
+    // 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}`);
+    try {
+      const MAX_TG = 4096;
+      const text = result.response;
+      if (text.length <= MAX_TG) {
+        await ctx.reply(text);
+      } else {
+        for (let i = 0; i < text.length; i += MAX_TG) {
+          await ctx.reply(text.slice(i, i + MAX_TG));
+        }
+      }
+      console.log(`[telegram] response sent chat_id=${chatId} length=${text.length}`);
     } catch (e) {
-      console.error(`[telegram] error chat_id=${chatId}: ${e.message}`);
+      console.error(`[telegram] delivery error chat_id=${chatId} length=${result.response.length}: ${e.message}`);
       await ctx.reply('Sorry, something went wrong. Please try again.');
     } finally {
       clearInterval(typingInterval);

package/src/server/tools.js

@@ -1,9 +1,11 @@
 import fs from 'fs';
 import { createRequire } from 'module';
 import path from 'path';
+import { fileURLToPath } from 'url';
 import { PATHS } from './config.js';
 
 const _require = createRequire(import.meta.url);
+const __jarvisDir = path.dirname(fileURLToPath(import.meta.url));
 const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;
 
 const TOOL_TIMEOUT_MS = 60_000;
@@ -122,7 +124,7 @@ const SEED_TOOLS = {
       type: 'function',
       function: {
         name: 'save_tool',
-        description: 'Create or update a custom tool and make it available immediately in this session. Use this to build reusable JS tools for tasks you repeat. The tool code runs in Node.js and has access to: args, fs, path, process, require.',
+        description: 'Create or update a custom tool and make it available immediately in this session. Use this to build reusable JS tools for tasks you repeat. The tool code runs in Node.js and has access to: args, fs, path, process, require, __jarvisDir.',
         parameters: {
           type: 'object',
           properties: {
@@ -140,7 +142,7 @@ const SEED_TOOLS = {
             },
             code: {
               type: 'string',
-              description: 'The body of an async function. Must end with a return statement — the returned value becomes the tool result. Available bindings: args (your tool parameters), fs (node:fs), path (node:path), process, require. Do NOT wrap in a function declaration. Example: const raw = await fs.promises.readFile(args.filePath, "utf8"); const data = JSON.parse(raw); return { count: data.length, first: data[0] };',
+              description: 'The body of an async function. Must end with a return statement — the returned value becomes the tool result. Available bindings: args (your tool parameters), fs (node:fs), path (node:path), process, require, __jarvisDir (absolute path to the jarvis server directory — use path.resolve(__jarvisDir, "../..") to get the project root for npm installs). Do NOT wrap in a function declaration. Example: const raw = await fs.promises.readFile(args.filePath, "utf8"); const data = JSON.parse(raw); return { count: data.length, first: data[0] };',
             },
           },
           required: ['name', 'description', 'parameters', 'code'],
@@ -164,6 +166,41 @@ const SEED_TOOLS = {
     },
     code: `const toolsFile = path.join(process.env.HOME, '.jarvis/data/tools/tools.json'); const raw = await fs.promises.readFile(toolsFile, 'utf8').catch(() => '{}'); const tools = JSON.parse(raw); const list = Object.entries(tools).map(([name, t]) => ({ name, description: t.definition.function.description })); return { status: 'ok', tools: list };`,
   },
+  npm_install: {
+    definition: {
+      type: 'function',
+      function: {
+        name: 'npm_install',
+        description: 'Install an npm package into the jarvis project so it can be used in tool code via require(). Always use this instead of exec to install packages.',
+        parameters: {
+          type: 'object',
+          properties: {
+            packageName: {
+              type: 'string',
+              description: 'The npm package name to install, e.g. "@perplexity-ai/sdk" or "axios".',
+            },
+          },
+          required: ['packageName'],
+        },
+      },
+    },
+    code: `
+      const { exec } = require('child_process');
+      const { promisify } = require('util');
+      const execAsync = promisify(exec);
+      const projectRoot = path.resolve(__jarvisDir, '../..');
+      try {
+        const { stdout, stderr } = await execAsync('npm install ' + args.packageName, {
+          cwd: projectRoot,
+          encoding: 'utf8',
+          timeout: 60000,
+        });
+        return { status: 'ok', packageName: args.packageName, stdout, stderr };
+      } catch (e) {
+        return { status: 'error', packageName: args.packageName, stderr: e.stderr || e.message };
+      }
+    `,
+  },
   get_recent_sessions: {
     definition: {
       type: 'function',
@@ -255,7 +292,7 @@ export async function executeTool(tools, name, toolArgs) {
     throw new Error(`Unknown tool: ${name}`);
   }
 
-  const fn = new AsyncFunction('args', 'fs', 'path', 'process', 'require', tool.code);
+  const fn = new AsyncFunction('args', 'fs', 'path', 'process', 'require', '__jarvisDir', tool.code);
 
   const timeout = new Promise((_, reject) =>
     setTimeout(
@@ -264,5 +301,5 @@ export async function executeTool(tools, name, toolArgs) {
     )
   );
 
-  return await Promise.race([fn(toolArgs, fs, path, process, _require), timeout]);
+  return await Promise.race([fn(toolArgs, fs, path, process, _require, __jarvisDir), timeout]);
 }