naisys 1.0.3 → 1.2.0

package/README.md

@@ -11,6 +11,10 @@ vim or nano so point the LLM to use cat to read/write files in a single operatio
 
 [NPM](https://www.npmjs.com/package/naisys) | [Website](https://naisys.org) | [Discord](https://discord.gg/JBUPWSbaEt) | [Demo Video](https://www.youtube.com/watch?v=Ttya3ixjumo)
 
+```bash
+npm install -g naisys
+```
+
 #### Node.js is used to create a simple proxy shell environment for the LLM that
 
 - Helps the LLM keep track of its current context size
@@ -61,7 +65,7 @@ title: Software Engineer
 
 # The model to use for console interactions
 # (gpt4turbo, gpt4turbo, gemini-pro, claude3sonnet, claude3opus, local)
-consoleModel: claude3sonnet
+shellModel: claude3sonnet
 
 # The model to use for llmynx, pre-processing websites to fit into a smaller context
 webModel: gpt3turbo
@@ -85,14 +89,26 @@ tokenMax: 5000
 # No value or zero means wait indefinitely (debug driven)
 debugPauseSeconds: 5
 
-# If true, regardless of the debugPauseSeconds, the agent will not wake up on messages
-# With lots of agents this could be costly if they all end up mailing/replying each other in quick succession
+# If true, regardless of the debugPauseSeconds, the agent will wake up on messages
+# Useful for agents with long debugPauseSeconds, so that they can wake up and reply quickly
 wakeOnMessage: false
 
 # The maximum amount to spend on LLM interactions
 # Once reached the agent will stop and this value will need to be increased to continue
 spendLimitDollars: 2.00
-# Additional custom variables can be defined here and/or in the .env file to be loaded into the agent prompt
+
+# Command Protection: Useful for agents you want to restrict from modifying the system
+#   None: Commands from the LLM run automatically, this is the default setting as well if the value is not set
+#   Manual: Every command the LLM wants to run has to be approved [y/n]. Not very autonomous.
+#   Auto: All commands are run through the separate LLM instace that will check to see if the command is safe
+commandProtection: "none"
+
+# Run these commands on session start, in the example below the agent will see how to use mail and a list of other agents
+initialCommands:
+  - llmail users
+  - llmail help
+  - cat ${env.NAISYS_FOLDER}/home/${agent.username}/PLAN.md
+# Additional custom variables can be defined here and/or in the agent config to be loaded into the agent prompt
 ```
 
 - Run `naisys <path to yaml or directory>`

package/bin/comment

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+# ./src/command/commandHandler.ts has the same message
+echo "Comment noted. Try running commands now to achieve your goal. ."

package/bin/endsession

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+echo "'endsession' cannot be used with other commands on the same prompt."

package/bin/llmail

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+echo "'llmail' cannot be used with other commands on the same prompt."

package/bin/llmynx

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+echo "'llmynx' cannot be used with other commands on the same prompt."

package/{naisys.sh → bin/naisys}

@@ -12,7 +12,7 @@ fi
 
 # Resolves the location of naisys from the bin directory
 SCRIPT=$(readlink -f "$0" || echo "$0")
-SCRIPT_DIR=$(dirname "$SCRIPT")
+SCRIPT_DIR=$(dirname "$SCRIPT")/..
 
 # if path is a yaml file then start a single agent
 if [ -f "$1" ]; then

package/bin/pause

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+echo "'pause' cannot be used with other commands on the same prompt."

package/dist/apps/llmail.js

@@ -6,9 +6,8 @@ import * as utilities from "../utils/utilities.js";
 import { naisysToHostPath } from "../utils/utilities.js";
 const _dbFilePath = naisysToHostPath(`${config.naisysFolder}/lib/llmail.db`);
 let _myUserId = -1;
-// Implement maxes so that LLMs actively manage threads, archive, and create new ones
-const _threadTokenMax = config.agent.tokenMax / 2; // So 4000, would be 2000 thread max
-const _messageTokenMax = _threadTokenMax / 5; // Given the above a 400 token max, and 5 big messages per thread
+/** Threading is not currently used so this doesn't matter */
+const _threadTokenMax = config.mailMessageTokenMax * 5;
 /** The 'non-simple' version of this is a thread first mail system. Where agents can create threads, add users, and reply to threads, etc..
  * The problem with this was the agents were too chatty with so many mail commands, wasting context replying, reading threads, etc..
  * Simple mode only has two commands. It still requires db persistance to support offline agents. */
@@ -85,7 +84,7 @@ export async function handleCommand(args) {
             if (simpleMode) {
                 return `llmail <command>
   users: Get list of users on the system
-  send "<users>" "subject" "message": Send a message. ${_messageTokenMax} token max.`;
+  send "<users>" "subject" "message": Send a message. ${config.mailMessageTokenMax} token max.`;
             }
             else {
                 return `llmail <command>
@@ -138,7 +137,8 @@ export async function handleCommand(args) {
             await init();
             return "llmail database reset";
         default:
-            return "Unknown llmail command: " + argParams[0];
+            return ("Error, unknown command. See valid commands below:\n" +
+                (await handleCommand("help")));
     }
 }
 export async function getUnreadThreads() {
@@ -339,12 +339,18 @@ async function getUser(db, username) {
 }
 function validateMsgTokenCount(message) {
     const msgTokenCount = utilities.getTokenCount(message);
-    if (msgTokenCount > _messageTokenMax) {
-        throw `Error: Message is ${msgTokenCount} tokens, exceeding the limit of ${_messageTokenMax} tokens`;
+    if (msgTokenCount > config.mailMessageTokenMax) {
+        throw `Error: Message is ${msgTokenCount} tokens, exceeding the limit of ${config.mailMessageTokenMax} tokens`;
     }
     return msgTokenCount;
 }
 async function usingDatabase(run) {
     return dbUtils.usingDatabase(_dbFilePath, run);
 }
+export async function hasMultipleUsers() {
+    return await usingDatabase(async (db) => {
+        const users = await db.all("SELECT * FROM Users");
+        return users.length > 1;
+    });
+}
 //# sourceMappingURL=llmail.js.map

package/dist/apps/llmynx.js

@@ -15,53 +15,50 @@ let _nextGlobalLinkNum = 1;
 export async function handleCommand(cmdArgs) {
     outputInDebugMode("LLMYNX DEBUG MODE IS ON");
     const argParams = cmdArgs.split(" ");
-    const defualtTokenMax = config.agent.tokenMax / 8;
     if (!argParams[0]) {
         argParams[0] = "help";
     }
     switch (argParams[0]) {
         case "help":
-            return `llmynx <command> (results will be reduced to around ${defualtTokenMax})
+            return `llmynx <command> (results will be reduced to around ${config.webTokenMax})
   search <query>: Search google for the given query
   open <url>: Opens the given url. Links are represented as numbers in brackets which prefix the word they are linking like [123]
   follow <link number>: Opens the given link number. Link numbers work across all previous outputs
-  links <url> <page>: Lists only the links for the given url. Use the page number to get more links`;
+  links <url> <page>: Lists only the links for the given url. Use the page number to get more links
+  
+*llmynx does not support input. Use llmynx or curl to call APIs directly*`;
         case "search": {
             const query = argParams.slice(1).join(" ");
-            return await loadUrl("https://www.google.com/search?q=" + encodeURIComponent(query), config.agent.tokenMax / 2, // Prevent form being reduced as google results are usually short anyways and we want to maintainq the links
-            true, true);
+            return await loadUrl("https://www.google.com/search?q=" + encodeURIComponent(query), true, true);
         }
         case "open": {
             const url = argParams[1];
-            const isNumber = !isNaN(parseInt(argParams[2]));
-            const tokenMax = isNumber ? parseInt(argParams[2]) : defualtTokenMax;
-            return await loadUrl(url, tokenMax, false, true);
+            return await loadUrl(url, false, true);
         }
         case "follow": {
             const linkNum = parseInt(argParams[1]);
-            const isNumber = !isNaN(parseInt(argParams[2]));
-            const tokenMax = isNumber ? parseInt(argParams[2]) : defualtTokenMax;
             const linkUrl = _globalLinkMap.get(linkNum);
             if (!linkUrl) {
                 return "Link number not found";
             }
-            return await loadUrl(linkUrl, tokenMax, true, false);
+            return await loadUrl(linkUrl, true, false);
         }
         case "links": {
             const url = argParams[1];
             const isNumber = !isNaN(parseInt(argParams[2]));
             const pageNumber = isNumber ? parseInt(argParams[2]) : 1;
-            return await loadUrl(url, 600, false, false, pageNumber);
+            return await loadUrl(url, false, false, pageNumber);
         }
         // Secret command to toggle debug mode
         case "debug":
             debugMode = !debugMode;
             return "Debug mode toggled " + (debugMode ? "on" : "off");
         default:
-            return "Unknown llmynx command: " + argParams[0];
+            return ("Error, unknown command. See valid commands below:\n" +
+                (await handleCommand("help")));
     }
 }
-async function loadUrl(url, tokenMax, showUrl, showFollowHint, linkPageAsContent) {
+async function loadUrl(url, showUrl, showFollowHint, linkPageAsContent) {
     let content = await runLynx(url);
     let links = "";
     // Reverse find 'References: ' and cut everything after it from the content
@@ -79,13 +76,13 @@ async function loadUrl(url, tokenMax, showUrl, showFollowHint, linkPageAsContent
     outputInDebugMode(`Content Token size: ${contentTokenSize}\n` +
         `Links Token size: ${linksTokenSize}`);
     // Reduce content using LLM if it's over the token max
-    if (contentTokenSize > tokenMax) {
+    if (contentTokenSize > config.webTokenMax) {
         const model = getLLModel(config.agent.webModel);
         // For example if context is 16k, and max tokens is 2k, 3k with 1.5x overrun
         // That would be 3k for the current compressed content, 10k for the chunk, and 3k for the output
-        let tokenChunkSize = model.maxTokens - tokenMax * 2 * 1.5;
+        let tokenChunkSize = model.maxTokens - config.webTokenMax * 2 * 1.5;
         if (linkPageAsContent) {
-            tokenChunkSize = tokenMax;
+            tokenChunkSize = config.webTokenMax;
         }
         outputInDebugMode(`Token max chunk size: ${tokenChunkSize}`);
         const pieceCount = Math.ceil(contentTokenSize / tokenChunkSize);
@@ -100,10 +97,10 @@ async function loadUrl(url, tokenMax, showUrl, showFollowHint, linkPageAsContent
                 }
                 continue;
             }
-            output.comment(`Processing Piece ${i + 1} of ${pieceCount}...`);
+            output.comment(`Processing Piece ${i + 1} of ${pieceCount} with ${model.key}...`);
             outputInDebugMode(`  Reduced output tokens: ${utilities.getTokenCount(reducedOutput)}\n` +
                 `  Current Piece tokens: ${utilities.getTokenCount(pieceStr)}`);
-            reducedOutput = await llmReduce(url, reducedOutput, i + 1, pieceCount, pieceStr, tokenMax);
+            reducedOutput = await llmReduce(url, reducedOutput, i + 1, pieceCount, pieceStr);
         }
         if (linkPageAsContent) {
             return "";
@@ -113,7 +110,7 @@ async function loadUrl(url, tokenMax, showUrl, showFollowHint, linkPageAsContent
         output.comment(`Content reduced from ${contentTokenSize} to ${finalTokenSize} tokens`);
     }
     else {
-        output.comment(`Content is already under ${tokenMax} tokens.`);
+        output.comment(`Content is already under ${config.webTokenMax} tokens.`);
     }
     // Prefix content with url if following as otherwise the url is never shown
     if (showUrl) {
@@ -132,22 +129,25 @@ async function runLynx(url) {
         const modeParams = "";
         const ifWindows = os.platform() === "win32" ? "wsl " : "";
         exec(`${ifWindows}lynx -dump ${modeParams} "${url}"`, (error, stdout, stderr) => {
-            if (error) {
-                resolve(`error: ${error.message}`);
-                return;
+            let output = "";
+            if (stdout) {
+                output += stdout;
+            }
+            // I've only seen either/or, but just in case
+            if (stdout && stderr) {
+                output += "\nError:\n";
             }
             if (stderr) {
-                resolve(`stderr: ${stderr}`);
-                return;
+                output += stderr;
             }
-            resolve(stdout);
+            resolve(output);
         });
     });
 }
-async function llmReduce(url, reducedOutput, pieceNumber, pieceTotal, pieceStr, tokenMax) {
+async function llmReduce(url, reducedOutput, pieceNumber, pieceTotal, pieceStr) {
     const systemMessage = `You will be iteratively fed the web page ${url} broken into ${pieceTotal} sequential equally sized pieces.
 Each piece should be reduced into the final content in order to maintain the meaning of the page while reducing verbosity and duplication.
-The final output should be around ${tokenMax} tokens. 
+The final output should be around ${config.webTokenMax} tokens. 
 Don't remove links which are represented as numbers in brackets which prefix the word they are linking like [123].
 Try to prioritize content of substance over advertising content.`;
     const content = `Web page piece ${pieceNumber} of ${pieceTotal}: 
@@ -156,7 +156,7 @@ ${pieceStr}
 Current reduced content: 
 ${reducedOutput}
 
-Please merge the new piece into the existing reduced content above while keeping the result to around ${tokenMax} tokens.
+Please merge the new piece into the existing reduced content above while keeping the result to around ${config.webTokenMax} tokens.
 
 Merged reduced content:
 `;

package/dist/command/commandHandler.js

@@ -11,6 +11,7 @@ import * as logService from "../utils/logService.js";
 import * as output from "../utils/output.js";
 import { OutputColor } from "../utils/output.js";
 import * as utilities from "../utils/utilities.js";
+import * as commandProtection from "./commandProtection.js";
 import * as promptBuilder from "./promptBuilder.js";
 import * as shellCommand from "./shellCommand.js";
 export var NextCommandAction;
@@ -20,7 +21,7 @@ export var NextCommandAction;
     NextCommandAction[NextCommandAction["ExitApplication"] = 2] = "ExitApplication";
 })(NextCommandAction || (NextCommandAction = {}));
 export let previousSessionNotes = await logService.getPreviousEndSessionNote();
-export async function consoleInput(prompt, consoleInput) {
+export async function processCommand(prompt, consoleInput) {
     // We process the lines one at a time so we can support multiple commands with line breaks
     let firstLine = true;
     let processNextLLMpromptBlock = true;
@@ -47,12 +48,20 @@ export async function consoleInput(prompt, consoleInput) {
                 await output.commentAndLog("Continuing with next command from same LLM response...");
                 await contextManager.append(input, ContentSource.LLM);
             }
+            // Run write protection checks if enabled
+            const { commandAllowed, rejectReason } = await commandProtection.validateCommand(input);
+            if (!commandAllowed) {
+                await output.errorAndLog(`Write Protection Triggered`);
+                await contextManager.append(rejectReason || "Unknown");
+                break;
+            }
         }
         const cmdParams = input.split(" ");
         const cmdArgs = input.slice(cmdParams[0].length).trim();
         switch (cmdParams[0]) {
             case "comment": {
                 // Important - Hint the LLM to turn their thoughts into accounts
+                // ./bin/comment shell script has the same message
                 await contextManager.append("Comment noted. Try running commands now to achieve your goal.");
                 break;
             }

package/dist/command/commandLoop.js

@@ -18,7 +18,7 @@ import * as promptBuilder from "./promptBuilder.js";
 const maxErrorCount = 5;
 export async function run() {
     // Show Agent Config exept the agent prompt
-    await output.commentAndLog(`Agent configured to use ${config.agent.consoleModel} model`);
+    await output.commentAndLog(`Agent configured to use ${config.agent.shellModel} model`);
     // Show System Message
     await output.commentAndLog("System Message:");
     const systemMessage = contextManager.getSystemMessage();
@@ -35,28 +35,29 @@ export async function run() {
         await output.commentAndLog("Starting Context:");
         await contextManager.append("Previous Session Note:");
         await contextManager.append(commandHandler.previousSessionNotes || "None");
-        await commandHandler.consoleInput(await promptBuilder.getPrompt(), "llmail help");
-        await commandHandler.consoleInput(await promptBuilder.getPrompt(), "llmail users");
+        for (const initialCommand of config.agent.initialCommands) {
+            await commandHandler.processCommand(await promptBuilder.getPrompt(0, false), config.resolveConfigVars(initialCommand));
+        }
         inputMode.toggle(InputMode.Debug);
         let pauseSeconds = config.agent.debugPauseSeconds;
         let wakeOnMessage = config.agent.wakeOnMessage;
         while (nextCommandAction == NextCommandAction.Continue) {
             const prompt = await promptBuilder.getPrompt(pauseSeconds, wakeOnMessage);
-            let input = "";
+            let consoleInput = "";
             // Debug command prompt
             if (inputMode.current === InputMode.Debug) {
-                input = await promptBuilder.getInput(`${prompt}`, pauseSeconds, wakeOnMessage);
+                consoleInput = await promptBuilder.getInput(`${prompt}`, pauseSeconds, wakeOnMessage);
             }
             // LLM command prompt
             else if (inputMode.current === InputMode.LLM) {
                 const workingMsg = prompt +
-                    chalk[output.OutputColor.loading](`LLM (${config.agent.consoleModel}) Working...`);
+                    chalk[output.OutputColor.loading](`LLM (${config.agent.shellModel}) Working...`);
                 try {
-                    await displayNewMail();
-                    await displayContextWarning();
+                    await checkNewMailNotification();
+                    await checkContextLimitWarning();
                     await contextManager.append(prompt, ContentSource.ConsolePrompt);
                     process.stdout.write(workingMsg);
-                    input = await llmService.query(config.agent.consoleModel, contextManager.getSystemMessage(), contextManager.messages, "console");
+                    consoleInput = await llmService.query(config.agent.shellModel, contextManager.getSystemMessage(), contextManager.messages, "console");
                     clearPromptMessage(workingMsg);
                 }
                 catch (e) {
@@ -73,7 +74,7 @@ export async function run() {
             // Run the command
             try {
                 ({ nextCommandAction, pauseSeconds, wakeOnMessage } =
-                    await commandHandler.consoleInput(prompt, input));
+                    await commandHandler.processCommand(prompt, consoleInput));
                 if (inputMode.current == InputMode.LLM) {
                     llmErrorCount = 0;
                 }
@@ -85,7 +86,7 @@ export async function run() {
             }
             // If the user is in debug mode and they didn't enter anything, switch to LLM
             // If in LLM mode, auto switch back to debug
-            if ((inputMode.current == InputMode.Debug && !input) ||
+            if ((inputMode.current == InputMode.Debug && !consoleInput) ||
                 inputMode.current == InputMode.LLM) {
                 inputMode.toggle();
             }
@@ -136,7 +137,7 @@ async function handleErrorAndSwitchToDebugMode(e, llmErrorCount, addToContext) {
         wakeOnMessage,
     };
 }
-async function displayNewMail() {
+async function checkNewMailNotification() {
     // Check for unread threads
     const unreadThreads = await llmail.getUnreadThreads();
     if (!unreadThreads.length) {
@@ -174,7 +175,7 @@ async function displayNewMail() {
             `Use llmail read <id>' to read the thread, but be mindful you are close to the token limit for the session.`, ContentSource.Console);
     }
 }
-async function displayContextWarning() {
+async function checkContextLimitWarning() {
     const tokenCount = contextManager.getTokenCount();
     const tokenMax = config.agent.tokenMax;
     if (tokenCount > tokenMax) {

package/dist/command/commandProtection.js

@@ -0,0 +1,49 @@
+import * as config from "../config.js";
+import { LlmRole } from "../llm/llmDtos.js";
+import * as llmService from "../llm/llmService.js";
+import { CommandProtection } from "../utils/enums.js";
+import * as output from "../utils/output.js";
+import * as promptBuilder from "./promptBuilder.js";
+export async function validateCommand(command) {
+    switch (config.agent.commandProtection) {
+        case CommandProtection.None:
+            return {
+                commandAllowed: true,
+            };
+        case CommandProtection.Manual: {
+            const confirmation = await promptBuilder.getCommandConfirmation();
+            const commandAllowed = confirmation.toLowerCase() === "y";
+            return {
+                commandAllowed,
+                rejectReason: commandAllowed ? undefined : "Command denied by admin",
+            };
+        }
+        case CommandProtection.Auto:
+            return await autoValidateCommand(command);
+        default:
+            throw "Write protection not configured correctly";
+    }
+}
+async function autoValidateCommand(command) {
+    output.comment("Checking if command is allowed...");
+    const systemMessage = `You are a command validator that checks if shell commands are ok to run.
+The user is 'junior admin' allowed to move around the system, anywhere, and read anything, list anything.
+They are not allowed to execute programs that could modify the system.
+Programs that just give information responses are ok.
+The user is allowed to write to their home directory in ${config.naisysFolder}/home/${config.agent.username}
+In addition to the commands you know are ok, these additional commands are whitelisted: 
+  llmail, llmynx, comment, endsession, and pause
+Reply with 'allow' to allow the command, otherwise you can give a reason for your rejection.`;
+    const response = await llmService.query(config.agent.shellModel, systemMessage, [
+        {
+            role: LlmRole.User,
+            content: command,
+        },
+    ], "write-protection");
+    const commandAllowed = response.toLocaleLowerCase().startsWith("allow");
+    return {
+        commandAllowed,
+        rejectReason: commandAllowed ? undefined : "Command Rejected: " + response,
+    };
+}
+//# sourceMappingURL=commandProtection.js.map

package/dist/command/promptBuilder.js

@@ -130,4 +130,11 @@ export function getInput(commandPrompt, pauseSeconds, wakeOnMessage) {
         }
     });
 }
+export function getCommandConfirmation() {
+    return new Promise((resolve) => {
+        _readlineInterface.question(chalk.greenBright("Allow command to run? [y/n] "), (answer) => {
+            resolve(answer);
+        });
+    });
+}
 //# sourceMappingURL=promptBuilder.js.map

package/dist/command/shellCommand.js

@@ -1,6 +1,8 @@
+import * as config from "../config.js";
 import * as contextManager from "../llm/contextManager.js";
 import * as inputMode from "../utils/inputMode.js";
 import { InputMode } from "../utils/inputMode.js";
+import * as utilities from "../utils/utilities.js";
 import * as shellWrapper from "./shellWrapper.js";
 export async function handleCommand(input) {
     const cmdParams = input.split(" ");
@@ -29,7 +31,22 @@ export async function handleCommand(input) {
     }
     const output = await shellWrapper.executeCommand(input);
     if (output.value) {
-        await contextManager.append(output.value);
+        let text = output.value;
+        let outputLimitExceeded = false;
+        const tokenCount = utilities.getTokenCount(text);
+        // Prevent too much output from blowing up the context
+        if (tokenCount > config.shellOutputTokenMax) {
+            outputLimitExceeded = true;
+            const trimLength = (text.length * config.shellOutputTokenMax) / tokenCount;
+            text =
+                text.slice(0, trimLength / 2) +
+                    "\n\n...\n\n" +
+                    text.slice(-trimLength / 2);
+        }
+        await contextManager.append(text);
+        if (outputLimitExceeded) {
+            await contextManager.append(`\nThe shell command generated too much output (${tokenCount} tokens). Only 2,000 tokens worth are shown above.`);
+        }
     }
     response.hasErrors = output.hasErrors;
     return response;

package/dist/command/shellWrapper.js

@@ -39,12 +39,12 @@ async function ensureOpen() {
     // Init users home dir on first run, on shell crash/rerun go back to the current path
     if (!_currentPath) {
         output.comment("NEW SHELL OPENED. PID: " + _process.pid);
-        commentIfNotEmpty(await executeCommand(`mkdir -p ${config.naisysFolder}/home/` + config.agent.username));
-        commentIfNotEmpty(await executeCommand(`cd ${config.naisysFolder}/home/` + config.agent.username));
+        errorIfNotEmpty(await executeCommand(`mkdir -p ${config.naisysFolder}/home/` + config.agent.username));
+        errorIfNotEmpty(await executeCommand(`cd ${config.naisysFolder}/home/` + config.agent.username));
     }
     else {
         output.comment("SHELL RESTORED. PID: " + _process.pid);
-        commentIfNotEmpty(await executeCommand("cd " + _currentPath));
+        errorIfNotEmpty(await executeCommand("cd " + _currentPath));
     }
     // Stop running commands if one fails
     // Often the LLM will give us back all kinds of invalid commands, we want to break on the first one
@@ -52,9 +52,9 @@ async function ensureOpen() {
     //commentIfNotEmpty(await executeCommand("set -e"));
 }
 /** Basically don't show anything in the console unless there is an error */
-function commentIfNotEmpty(response) {
+function errorIfNotEmpty(response) {
     if (response.value) {
-        output.comment(response.value);
+        output.error(response.value);
     }
 }
 export function processOutput(dataStr, eventType) {
@@ -128,19 +128,22 @@ export async function executeCommand(command) {
         const commandWithDelimiter = `${command.trim()}\necho "${_commandDelimiter} LINE:\${LINENO}"\n`;
         //_log += "INPUT: " + commandWithDelimiter;
         _process === null || _process === void 0 ? void 0 : _process.stdin.write(commandWithDelimiter);
-        // If no response after 5 seconds, kill and reset the shell, often hanging on some unescaped input
-        const timeoutSeconds = 5;
-        _currentCommandTimeout = setTimeout(() => {
-            if (_resolveCurrentCommand) {
-                _process === null || _process === void 0 ? void 0 : _process.kill();
-                output.error("SHELL TIMEMOUT/KILLED. PID: " + (_process === null || _process === void 0 ? void 0 : _process.pid));
-                resetProcess();
-                _resolveCurrentCommand({
-                    value: `Error: Command timed out after ${timeoutSeconds} seconds.`,
-                    hasErrors: true,
-                });
-            }
-        }, timeoutSeconds * 1000);
+        // If no response, kill and reset the shell, often hanging on some unescaped input
+        _currentCommandTimeout = setTimeout(resetShell, config.shellCommmandTimeoutSeconds * 1000);
+    });
+}
+function resetShell() {
+    if (!_resolveCurrentCommand) {
+        return;
+    }
+    _process === null || _process === void 0 ? void 0 : _process.kill();
+    output.error("SHELL TIMEMOUT/KILLED. PID: " + (_process === null || _process === void 0 ? void 0 : _process.pid));
+    const outputWithError = _commandOutput.trim() +
+        `\nError: Command timed out after ${config.shellCommmandTimeoutSeconds} seconds.`;
+    resetProcess();
+    _resolveCurrentCommand({
+        value: outputWithError,
+        hasErrors: true,
     });
 }
 export async function getCurrentPath() {
@@ -167,14 +170,16 @@ function resetProcess() {
  * May also help with common escaping errors */
 function runCommandFromScript(command) {
     const scriptPath = `${config.naisysFolder}/home/${config.agent.username}/.command.tmp.sh`;
-    // set -e causes the script to exit on any error
+    // set -e causes the script to exit on the first error
     const scriptContent = `#!/bin/bash
 set -e
 cd ${_currentPath}
 ${command.trim()}`;
     // create/writewrite file
     fs.writeFileSync(naisysToHostPath(scriptPath), scriptContent);
-    // Source will run the script in the current shell, so any change directories in the script should persist in the current shell
-    return `source ${scriptPath}`;
+    // `Path` is set to the ./bin folder because custom NAISYS commands that follow shell commands will be handled by the shell, which will fail
+    // so we need to remind the LLM that 'naisys commands cannot be used with other commands on the same prompt'
+    // `source` will run the script in the current shell, so any change directories in the script will persist in the current shell
+    return `PATH=${config.binPath}:$PATH source ${scriptPath}`;
 }
 //# sourceMappingURL=shellWrapper.js.map

package/dist/config.js

@@ -2,11 +2,16 @@ import { program } from "commander";
 import dotenv from "dotenv";
 import * as fs from "fs";
 import yaml from "js-yaml";
+import { CommandProtection } from "./utils/enums.js";
 import { valueFromString } from "./utils/utilities.js";
 program.argument("<agent-path>", "Path to agent configuration file").parse();
 dotenv.config();
 /** The system name that shows after the @ in the command prompt */
 export const hostname = "naisys";
+export const shellOutputTokenMax = 2500; // Limits the size of files that can be read/wrote
+export const shellCommmandTimeoutSeconds = 15; // The number of seconds NAISYS will wait for a shell command to complete
+export const webTokenMax = 2500;
+export const mailMessageTokenMax = 400;
 /* .env is used for global configs across naisys, while agent configs are for the specific agent */
 export const naisysFolder = getEnv("NAISYS_FOLDER", true);
 export const websiteFolder = getEnv("WEBSITE_FOLDER");
@@ -16,34 +21,45 @@ export const openaiApiKey = getEnv("OPENAI_API_KEY");
 export const googleApiKey = getEnv("GOOGLE_API_KEY");
 export const anthropicApiKey = getEnv("ANTHROPIC_API_KEY");
 export const agent = loadAgentConfig();
-function getEnv(key, required) {
-    const value = process.env[key];
-    if (!value && required) {
-        throw `Config: Error, .env ${key} is not defined`;
-    }
-    return value;
-}
 function loadAgentConfig() {
     const agentPath = program.args[0];
-    const checkAgentConfig = yaml.load(fs.readFileSync(agentPath, "utf8"));
+    const config = yaml.load(fs.readFileSync(agentPath, "utf8"));
     // throw if any property is undefined
     for (const key of [
         "username",
         "title",
-        "consoleModel",
+        "shellModel",
         "webModel",
         "agentPrompt",
         "spendLimitDollars",
         "tokenMax",
-        // debugPauseSeconds and wakeOnMessage can be undefined
+        // other properties can be undefined
     ]) {
-        if (!valueFromString(checkAgentConfig, key)) {
+        if (!valueFromString(config, key)) {
             throw `Agent config: Error, ${key} is not defined`;
         }
     }
-    return checkAgentConfig;
+    // Sanitize input
+    if (!config.initialCommands) {
+        config.initialCommands = [];
+    }
+    else if (!Array.isArray(config.initialCommands)) {
+        throw `Agent config: Error, 'initialCommands' is not an array`;
+    }
+    config.debugPauseSeconds = config.debugPauseSeconds
+        ? Number(config.debugPauseSeconds)
+        : 0;
+    config.wakeOnMessage = Boolean(config.wakeOnMessage);
+    if (!config.commandProtection) {
+        config.commandProtection = CommandProtection.None;
+    }
+    if (!Object.values(CommandProtection).includes(config.commandProtection)) {
+        throw `Agent config: Error, 'commandProtection' is not a valid value`;
+    }
+    return config;
 }
 export const packageVersion = await getVersion();
+export const binPath = getBinPath();
 /** Can only get version from env variable when naisys is started with npm,
  * otherwise need to rip it from the package ourselves relative to where this file is located */
 async function getVersion() {
@@ -58,4 +74,35 @@ async function getVersion() {
         return "0.1";
     }
 }
+function getEnv(key, required) {
+    const value = process.env[key];
+    if (!value && required) {
+        throw `Config: Error, .env ${key} is not defined`;
+    }
+    return value;
+}
+export function resolveConfigVars(templateString) {
+    let resolvedString = templateString;
+    resolvedString = resolveTemplateVars(resolvedString, "agent", agent);
+    resolvedString = resolveTemplateVars(resolvedString, "env", process.env);
+    return resolvedString;
+}
+function resolveTemplateVars(templateString, allowedVarString, mappedVar) {
+    const pattern = new RegExp(`\\$\\{${allowedVarString}\\.([^}]+)\\}`, "g");
+    return templateString.replace(pattern, (match, key) => {
+        const value = valueFromString(mappedVar, key);
+        if (value === undefined) {
+            throw `Agent config: Error, ${key} is not defined`;
+        }
+        return value;
+    });
+}
+function getBinPath() {
+    // C:/git/naisys/dist/config.js
+    let binPath = new URL("../bin", import.meta.url).pathname;
+    if (binPath.startsWith("/C:")) {
+        binPath = "/mnt/c" + binPath.substring(3);
+    }
+    return binPath;
+}
 //# sourceMappingURL=config.js.map

package/dist/llm/contextManager.js

@@ -5,7 +5,6 @@ import * as logService from "../utils/logService.js";
 import * as output from "../utils/output.js";
 import { OutputColor } from "../utils/output.js";
 import * as utilities from "../utils/utilities.js";
-import { valueFromString } from "../utils/utilities.js";
 import { LlmRole } from "./llmDtos.js";
 export var ContentSource;
 (function (ContentSource) {
@@ -23,8 +22,7 @@ export function getSystemMessage() {
     // A lot of the stipulations in here are to prevent common LLM mistakes
     // Like we can't jump between standard and special commands in a single prompt, which the LLM will try to do if not warned
     let agentPrompt = config.agent.agentPrompt;
-    agentPrompt = resolveTemplateVars(agentPrompt, "agent", config.agent);
-    agentPrompt = resolveTemplateVars(agentPrompt, "env", process.env);
+    agentPrompt = config.resolveConfigVars(agentPrompt);
     const systemMessage = `${agentPrompt.trim()}
 
 This is a command line interface presenting you with the next command prompt. 
@@ -38,12 +36,12 @@ NAISYS ${config.packageVersion} Shell
 Welcome back ${config.agent.username}!
 MOTD:
 Date: ${new Date().toLocaleString()}
-Commands: 
-  Standard Unix commands are available
+LINUX Commands: 
+  Standard Linux commands are available
   vi and nano are not supported
   Read files with cat. Write files with \`cat > filename << 'EOF'\`
   Do not input notes after the prompt. Only valid commands.
-Special Commands: (Don't mix with standard commands on the same prompt)
+NAISYS Commands: (cannot be used with other commands on the same prompt)
   llmail: A local mail system for communicating with your team
   llmynx: A context optimized web browser. Enter 'llmynx help' to learn how to use it
   comment "<thought>": Any non-command output like thinking out loud, prefix with the 'comment' command
@@ -51,23 +49,12 @@ Special Commands: (Don't mix with standard commands on the same prompt)
   endsession "<note>": Ends this session, clears the console log and context.
     The note should help you find your bearings in the next session. 
     The note should contain your next goal, and important things should you remember.
-    Try to keep the note around 400 tokens.
 Tokens:
   The console log can only hold a certain number of 'tokens' that is specified in the prompt
   Make sure to call endsession before the limit is hit so you can continue your work with a fresh console`;
     _cachedSystemMessage = systemMessage;
     return systemMessage;
 }
-function resolveTemplateVars(templateString, allowedVarString, mappedVar) {
-    const pattern = new RegExp(`\\$\\{${allowedVarString}\\.([^}]+)\\}`, "g");
-    return templateString.replace(pattern, (match, key) => {
-        const value = valueFromString(mappedVar, key);
-        if (value === undefined) {
-            throw `Agent config: Error, ${key} is not defined`;
-        }
-        return value;
-    });
-}
 export let messages = [];
 export async function append(text, source = ContentSource.Console) {
     // Debug runs in a shadow mode where their activity is not recorded in the context

package/dist/llm/llmService.js

@@ -80,24 +80,37 @@ async function sendWithGoogle(modelKey, systemMessage, context, source) {
     if (lastMessage.role !== LlmRole.User) {
         throw "Error, last message on context is not a user message";
     }
+    const contextHistory = context
+        .filter((m) => m != lastMessage)
+        .map((m) => ({
+        role: m.role == LlmRole.Assistant ? "model" : "user",
+        parts: [
+            {
+                text: m.content,
+            },
+        ],
+    }));
     const history = [
         {
             role: LlmRole.User, // System role is not supported by Google API
-            parts: systemMessage,
+            parts: [
+                {
+                    text: systemMessage,
+                },
+            ],
         },
         {
             role: "model",
-            parts: "Understood",
+            parts: [
+                {
+                    text: "Understood",
+                },
+            ],
         },
-        ...context
-            .filter((m) => m != lastMessage)
-            .map((m) => ({
-            role: m.role == LlmRole.Assistant ? "model" : LlmRole.User,
-            parts: m.content,
-        })),
+        ...contextHistory,
     ];
     const chat = googleModel.startChat({
-        history: history,
+        history,
         generationConfig: {
             maxOutputTokens: 2000,
         },

package/dist/utils/enums.js

@@ -0,0 +1,9 @@
+/* To separate enums from services which is useful for mocking where the enum
+is used across the code base, but the service it originates from is mocked. */
+export var CommandProtection;
+(function (CommandProtection) {
+    CommandProtection["None"] = "none";
+    CommandProtection["Manual"] = "manual";
+    CommandProtection["Auto"] = "auto";
+})(CommandProtection || (CommandProtection = {}));
+//# sourceMappingURL=enums.js.map

package/package.json

@@ -1,27 +1,28 @@
 {
   "name": "naisys",
   "description": "Node.js Autonomous Intelligence System",
-  "version": "1.0.3",
+  "version": "1.2.0",
   "type": "module",
   "main": "dist/naisys.js",
   "preferGlobal": true,
   "bin": {
-    "naisys": "naisys.sh"
+    "naisys": "./bin/naisys"
   },
   "scripts": {
-    "compile/run/attachable": "tsc && node --inspect dist/naisys.js ./agents/example.yaml",
-    "run agent:dev": "node dist/naisys.js ./agents/eva-site-2-team/dev.yaml",
-    "run agent:admin": "node dist/naisys.js ./agents/eva-site-2-team/admin.yaml",
+    "compile/run/attachable": "tsc && node --inspect dist/naisys.js ./agents/webdev-fansite.yaml",
+    "run agent:p1": "node dist/naisys.js ./agents/webdev-battle/player1.yaml",
+    "run agent:p2": "node dist/naisys.js ./agents/webdev-battle/player2.yaml",
     "clean": "rm -rf dist",
-    "clean:win": "wsl rm -rf dist",
-    "compile": "tsc",
+    "compile": "tsc --build --verbose",
     "eslint": "npx eslint --rulesdir eslint-rules src",
     "test": "tsc && node --experimental-vm-modules node_modules/jest/bin/jest.js --testPathPattern=dist/__tests__",
     "prettier": "npx prettier --write .",
     "dependency-graph": "madge --image dependency-graph.png dist",
     "detect-cycles": "madge --circular dist",
     "updates:check": "npm-check-updates",
-    "updates:apply": "npm-check-updates -u && npm update"
+    "updates:apply": "npm-check-updates -u && npm update",
+    "npm:publish:dryrun": "npm run clean && npm run compile && npm publish --dry-run",
+    "postinstall": "chmod +x ./bin/*"
   },
   "repository": {
     "type": "git",
@@ -37,22 +38,23 @@
   ],
   "author": "John Marshall",
   "license": "MIT",
+  "homepage": "https://naisys.org",
   "devDependencies": {
     "@types/escape-html": "1.0.4",
     "@types/js-yaml": "4.0.9",
-    "@types/node": "20.11.25",
+    "@types/node": "20.11.26",
     "@types/text-table": "0.2.5",
-    "@typescript-eslint/eslint-plugin": "7.1.1",
-    "@typescript-eslint/parser": "7.1.1",
+    "@typescript-eslint/eslint-plugin": "7.2.0",
+    "@typescript-eslint/parser": "7.2.0",
     "eslint": "8.57.0",
     "jest": "29.7.0",
     "prettier": "3.2.5",
     "ts-node": "10.9.2",
-    "typescript": "5.3.3"
+    "typescript": "5.4.2"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "0.16.1",
-    "@google/generative-ai": "0.2.1",
+    "@anthropic-ai/sdk": "0.17.2",
+    "@google/generative-ai": "0.3.0",
     "chalk": "5.3.0",
     "commander": "12.0.0",
     "dotenv": "16.4.5",