naisys 1.5.0 → 1.6.0

package/README.md

@@ -1,13 +1,18 @@
 ## NAISYS (Node.js Autonomous Intelligence System)
 
-NAISYS acts as a proxy shell between LLM(s) and a real shell. The goal is to see how far a LLM can
-get into writing a website from scratch as well as work with other LLM agents on the same project. Trying to figure
-out what works and what doesn't when it comes to 'cognitive architectures' for autonomy. NAISYS isn't
-limited to websites, but it seemed like a good place to start.
+NAISYS allows any LLM you want to operate a standard linux shell given your instructions. You can control how much
+to spend, the maximum number of tokens to use per session, how long to wait between commands, etc.. Between each command
+NAISYS will wait a few seconds to accept any input you want to put in yourself in case you want to colllaborate with the 
+LLM, give it hints, and/or diagnose the session.  Once the LLM reaches the token max you specified for the sesssion it
+will wrap things up, and start a fresh shell for the LLM to continue on its work. 
 
-Since the LLM has a limited context, NAISYS takes this into account and helps the LLM
-perform 'context friendly' operations. For example reading/writing a file can't use a typical editor like
-vim or nano so point the LLM to use cat to read/write files in a single operation.
+NAISYS tries to be a minimal wrapper, just helping the LLM operate in the shell 'better'. Making commands 'context friendly'. For instace if a command is long running, NAISYS will interrupt it, show the LLM the current output, and ask the LLM what it wants to 
+do next - wait, kill, or send input. The custom command prompt helps the LLM keep track of its token usage during the session. The 'comment' command helps the LLM think outloud without putting invalid commands into the shell. 
+
+Some use cases are building websites, diagnosing a system for security concerns, mapping out the topology of the local 
+network, learning and performing arbitrary tasks, or just plain exploring the limits of autonomy. NAISYS has a built-in 
+system for inter-agent communiation. You can manually startup mulitple instances of NAISYS with different roles, or 
+you can allow agents to start their own sub-agents on demand with instructions defined by the LLM itself!
 
 [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)
 
@@ -194,9 +199,16 @@ initialCommands:
 - To use NAISYS on Windows you need to run it locally from source (or from within WSL)
 - Use the above instructions to install locally, and then continue with the instructions below
 - Install WSL (Windows Subsystem for Linux)
+- Install a Linux distribution, Ubuntu can easily be installed from the Microsoft Store
 - The `NAISYS_FOLDER` and `WEBSITE_FOLDER` should be set to the WSL path
   - So `C:\var\naisys` should be `/mnt/c/var/naisys` in the `.env` file
 
+#### Notes for MacOS users
+
+- The browser llmynx requires `timeout` and `lynx`. Run these commands to install them:
+  - `brew install coreutils`
+  - `brew install lynx`
+
 #### Using NAISYS for a website
 
 - Many frameworks come with their own dev server
@@ -205,6 +217,7 @@ initialCommands:
 
 ## Changelog
 
+- 1.6: Support for long running shell commands and full screen terminal output
 - 1.5: Allow agents to start their own parallel `subagents`
 - 1.4: `genimg` command for generating images
 - 1.3: Post-session 'dreaming' as well as a mail 'blackout' period

package/dist/command/commandHandler.js

@@ -78,6 +78,10 @@ export async function processCommand(prompt, consoleInput) {
                 if (!config.endSessionEnabled) {
                     throw 'The "trimsession" command is not enabled in this environment.';
                 }
+                if (shellCommand.isShellSuspended()) {
+                    await contextManager.append("Session cannot be ended while a shell command is active.");
+                    break;
+                }
                 // Don't need to check end line as this is the last command in the context, just read to the end
                 const endSessionNotes = utilities.trimChars(cmdArgs, '"');
                 if (!endSessionNotes) {
@@ -158,8 +162,8 @@ export async function processCommand(prompt, consoleInput) {
                     ? NextCommandAction.ExitApplication
                     : NextCommandAction.Continue;
             }
-        }
-    }
+        } // End switch
+    } // End loop processing LLM response
     // display unprocessed lines to aid in debugging
     if (consoleInput.trim()) {
         await output.errorAndLog(`Unprocessed LLM response:\n${consoleInput}`);
@@ -227,6 +231,13 @@ async function splitMultipleInputCommands(nextInput) {
         input = nextInput.slice(0, newLinePos);
         nextInput = nextInput.slice(newLinePos).trim();
     }
+    // If shell is suspended, the process can kill/wait the shell, and may run some commands after
+    else if (newLinePos > 0 &&
+        shellCommand.isShellSuspended() &&
+        (nextInput.startsWith("kill") || nextInput.startsWith("wait"))) {
+        input = nextInput.slice(0, newLinePos);
+        nextInput = nextInput.slice(newLinePos).trim();
+    }
     // Else process the entire input now
     else {
         input = nextInput;

package/dist/command/commandLoop.js

@@ -19,6 +19,7 @@ import * as utilities from "../utils/utilities.js";
 import * as commandHandler from "./commandHandler.js";
 import { NextCommandAction } from "./commandHandler.js";
 import * as promptBuilder from "./promptBuilder.js";
+import * as shellCommand from "./shellCommand.js";
 const maxErrorCount = 5;
 export async function run() {
     // Show Agent Config exept the agent prompt
@@ -52,6 +53,9 @@ export async function run() {
         let pauseSeconds = config.agent.debugPauseSeconds;
         let wakeOnMessage = config.agent.wakeOnMessage;
         while (nextCommandAction == NextCommandAction.Continue) {
+            if (shellCommand.isShellSuspended()) {
+                await contextManager.append(`Command still running. Enter 'wait' to continue waiting. 'kill' to terminate. Other input will be sent to the process.`, ContentSource.Console);
+            }
             let prompt = await promptBuilder.getPrompt(pauseSeconds, wakeOnMessage);
             let consoleInput = "";
             // Debug command prompt

package/dist/command/promptBuilder.js

@@ -8,28 +8,35 @@ import * as inputMode from "../utils/inputMode.js";
 import { InputMode } from "../utils/inputMode.js";
 import * as output from "../utils/output.js";
 import * as shellWrapper from "./shellWrapper.js";
-// When actual output is entered by the user we want to cancel any auto-continue timers and/or wake on message
-// We don't want to cancel if the user is entering a chords like ctrl+b then down arrow, when using tmux
-// This is why we can't put the event listener on the standard process.stdin/keypress event.
-// There is no 'data entered' output event so this monkey patch does that
+/**
+ * When actual output is entered by the user we want to cancel any auto-continue timers and/or wake on message
+ * We don't want to cancel if the user is entering a chords like ctrl+b then down arrow, when using tmux
+ * This is why we can't put the event listener on the standard process.stdin/keypress event.
+ * There is no 'data entered' output event so this monkey patch does that
+ */
+const _writeEventEmitter = new events.EventEmitter();
 const _writeEventName = "write";
-const _outputEmitter = new events.EventEmitter();
 const _originalWrite = process.stdout.write.bind(process.stdout);
 process.stdout.write = (...args) => {
-    _outputEmitter.emit(_writeEventName, false, ...args);
+    _writeEventEmitter.emit(_writeEventName, false, ...args);
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return _originalWrite.apply(process.stdout, args);
 };
-const _readlineInterface = readline.createInterface({
+/**
+ * Tried to make this local and have it cleaned up with close() after using it, but
+ * due to the terminal settings below there are bugs with both terminal true and false
+ * pause() actually is nice in that it queues up the input, and doesn't allow the user
+ * to enter anything while the LLM is working
+ */
+const readlineInterface = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
+    // With this set to ture, after an abort the second input will not be processed, see:
+    // https://gist.github.com/swax/964a2488494048c8e03d05493d9370f8
+    // With this set to false, the stdout.write event above will not be triggered
+    terminal: true,
 });
-// Happens when ctrl+c is pressed
-let readlineInterfaceClosed = false;
-_readlineInterface.on("close", () => {
-    readlineInterfaceClosed = true;
-    output.error("Readline interface closed");
-});
+readlineInterface.pause();
 export async function getPrompt(pauseSeconds, wakeOnMessage) {
     const promptSuffix = inputMode.current == InputMode.Debug ? "#" : "$";
     const tokenMax = config.agent.tokenMax;
@@ -60,27 +67,24 @@ export function getInput(commandPrompt, pauseSeconds, wakeOnMessage) {
         let timeout;
         let interval;
         let timeoutCancelled = false;
-        if (readlineInterfaceClosed) {
-            output.error("Hanging because readline interface is closed.");
-            return;
+        function clearTimers() {
+            timeoutCancelled = true;
+            _writeEventEmitter.off(_writeEventName, cancelWaitingForUserInput);
+            clearTimeout(timeout);
+            clearInterval(interval);
         }
         /** Cancels waiting for user input */
-        function onStdinWrite_cancelTimers(questionAborted, buffer) {
+        const cancelWaitingForUserInput = (questionAborted, buffer) => {
             // Don't allow console escape commands like \x1B[1G to cancel the timeout
             if (timeoutCancelled || (buffer && !/^[a-zA-Z0-9 ]+$/.test(buffer))) {
                 return;
             }
-            timeoutCancelled = true;
-            _outputEmitter.off(_writeEventName, onStdinWrite_cancelTimers);
-            clearTimeout(timeout);
-            clearInterval(interval);
-            timeout = undefined;
-            interval = undefined;
+            clearTimers();
             if (questionAborted) {
                 return;
             }
-            // Else timeout interrupted by user input, clear out the timeout information from the prompt
-            // to prevent the user from thinking the timeout still applies
+            // Else timeout interrupted by user input
+            // Clear out the timeout information from the prompt to prevent the user from thinking the timeout still applies
             let pausePos = commandPrompt.indexOf("[Paused:");
             pausePos =
                 pausePos == -1 ? commandPrompt.indexOf("[WakeOnMsg]") : pausePos;
@@ -92,21 +96,22 @@ export function getInput(commandPrompt, pauseSeconds, wakeOnMessage) {
                 process.stdout.write("-".repeat(charsBack - 3));
                 readline.moveCursor(process.stdout, 3, 0);
             }
-        }
-        _readlineInterface.question(chalk.greenBright(commandPrompt), { signal: questionController.signal }, (answer) => {
+        };
+        readlineInterface.question(chalk.greenBright(commandPrompt), { signal: questionController.signal }, (answer) => {
+            clearTimers();
+            readlineInterface.pause();
             resolve(answer);
         });
         // If user starts typing in prompt, cancel any auto timeouts or wake on msg
-        _outputEmitter.on(_writeEventName, onStdinWrite_cancelTimers);
-        const abortQuestion = () => {
-            onStdinWrite_cancelTimers(true);
+        _writeEventEmitter.on(_writeEventName, cancelWaitingForUserInput);
+        function abortQuestion() {
+            cancelWaitingForUserInput(true);
             questionController.abort();
+            readlineInterface.pause();
             resolve("");
-        };
+        }
         if (pauseSeconds) {
-            timeout = setTimeout(() => {
-                abortQuestion();
-            }, pauseSeconds * 1000);
+            timeout = setTimeout(abortQuestion, pauseSeconds * 1000);
         }
         if (wakeOnMessage) {
             // Break timeout if new message is received
@@ -133,7 +138,8 @@ export function getInput(commandPrompt, pauseSeconds, wakeOnMessage) {
 }
 export function getCommandConfirmation() {
     return new Promise((resolve) => {
-        _readlineInterface.question(chalk.greenBright("Allow command to run? [y/n] "), (answer) => {
+        readlineInterface.question(chalk.greenBright("Allow command to run? [y/n] "), (answer) => {
+            readlineInterface.pause();
             resolve(answer);
         });
     });

package/dist/command/shellCommand.js

@@ -4,27 +4,35 @@ 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 const isShellSuspended = () => shellWrapper.isShellSuspended();
 export async function handleCommand(input) {
     const cmdParams = input.split(" ");
-    // Route user to context friendly edit commands that can read/write the entire file in one go
-    // Having EOF in quotes is important as it prevents the shell from replacing $variables with bash values
-    if (["nano", "vi", "vim"].includes(cmdParams[0])) {
-        throw `${cmdParams[0]} not supported. Use \`cat\` to read a file and \`cat > filename << 'EOF'\` to write a file`;
-    }
-    if (cmdParams[0] == "lynx" && cmdParams[1] != "--dump") {
-        throw `Interactive mode with lynx is not supported. Use --dump with lynx to view a website`;
-    }
-    if (cmdParams[0] == "exit") {
-        if (inputMode.current == InputMode.LLM) {
-            throw "Use 'endsession' to end the session and clear the console log.";
+    let response;
+    if (!isShellSuspended()) {
+        if (["nano", "vi", "vim"].includes(cmdParams[0])) {
+            // Route user to context friendly edit commands that can read/write the entire file in one go
+            // Having EOF in quotes is important as it prevents the shell from replacing $variables with bash values
+            throw `${cmdParams[0]} not supported. Use \`cat\` to read a file and \`cat > filename << 'EOF'\` to write a file`;
         }
-        // Only the debug user is allowed to exit the shell
-        else if (inputMode.current == InputMode.Debug) {
-            await shellWrapper.terminate();
-            return true;
+        if (cmdParams[0] == "lynx" && cmdParams[1] != "--dump") {
+            throw `Interactive mode with lynx is not supported. Use --dump with lynx to view a website`;
         }
+        if (cmdParams[0] == "exit") {
+            if (inputMode.current == InputMode.LLM) {
+                throw "Use 'endsession' to end the session and clear the console log.";
+            }
+            // Only the debug user is allowed to exit the shell
+            else if (inputMode.current == InputMode.Debug) {
+                await shellWrapper.terminate();
+                return true;
+            }
+        }
+        response = await shellWrapper.executeCommand(input);
+    }
+    // Else shell is suspended, continue
+    else {
+        response = await shellWrapper.continueCommand(input);
     }
-    let response = await shellWrapper.executeCommand(input);
     let outputLimitExceeded = false;
     const tokenCount = utilities.getTokenCount(response);
     // Prevent too much output from blowing up the context
@@ -41,9 +49,9 @@ export async function handleCommand(input) {
     }
     if (response.endsWith(": command not found")) {
         response +=
-            "Please enter a valid Linux or NAISYS command after the prompt. Use the 'comment' command for thoughts.";
+            "\nPlease enter a valid Linux or NAISYS command after the prompt. Use the 'comment' command for thoughts.";
     }
-    // todo move this into the command handler to remove the context manager dependency
+    // TODO: move this into the command handler to remove the context manager dependency
     await contextManager.append(response);
     return false;
 }

package/dist/command/shellWrapper.js

@@ -1,8 +1,12 @@
+import xterm from "@xterm/headless";
 import { spawn } from "child_process";
 import * as fs from "fs";
 import * as os from "os";
+import stripAnsi from "strip-ansi";
+import treeKill from "tree-kill";
 import * as config from "../config.js";
 import * as output from "../utils/output.js";
+import * as pathService from "../utils/pathService.js";
 import { NaisysPath } from "../utils/pathService.js";
 var ShellEvent;
 (function (ShellEvent) {
@@ -14,31 +18,35 @@ let _process;
 let _currentProcessId;
 let _commandOutput = "";
 let _currentPath;
+let _terminal;
+let _bufferChangeEvent;
+let _currentBufferType = "normal";
 let _resolveCurrentCommand;
 let _currentCommandTimeout;
-let _startTime;
 /** How we know the command has completed when running the command inside a shell like bash or wsl */
 const _commandDelimiter = "__COMMAND_END_X7YUTT__";
+let _wrapperSuspended = false;
+const _queuedOutput = [];
 async function ensureOpen() {
     if (_process) {
         return;
     }
     resetCommand();
-    const spawnProcess = os.platform() === "win32" ? "wsl" : "bash";
-    _process = spawn(spawnProcess, [], { stdio: "pipe" });
+    const spawnCmd = os.platform() === "win32" ? "wsl" : "bash";
+    _process = spawn(spawnCmd, [], { stdio: "pipe" });
     const pid = _process.pid;
     if (!pid) {
         throw "Shell process failed to start";
     }
     _currentProcessId = pid;
     _process.stdout.on("data", (data) => {
-        processOutput(data.toString(), ShellEvent.Ouptput, pid);
+        processOutput(data, ShellEvent.Ouptput, pid);
     });
     _process.stderr.on("data", (data) => {
-        processOutput(data.toString(), ShellEvent.Error, pid);
+        processOutput(data, ShellEvent.Error, pid);
     });
     _process.on("close", (code) => {
-        processOutput(`${code}`, ShellEvent.Exit, pid);
+        processOutput(Buffer.from(`${code}`), ShellEvent.Exit, pid);
     });
     // Init users home dir on first run, on shell crash/rerun go back to the current path
     if (!_currentPath) {
@@ -61,7 +69,12 @@ function errorIfNotEmpty(response) {
         output.error(response);
     }
 }
-function processOutput(dataStr, eventType, pid) {
+function processOutput(rawDataStr, eventType, pid) {
+    if (_wrapperSuspended) {
+        _queuedOutput.push({ rawDataStr, eventType, pid });
+        return;
+    }
+    let dataStr = stripAnsi(rawDataStr.toString());
     if (pid != _currentProcessId) {
         output.comment(`Ignoring '${eventType}' from old shell process ${pid}: ` + dataStr);
         return;
@@ -72,75 +85,170 @@ function processOutput(dataStr, eventType, pid) {
         return;
     }
     if (eventType === ShellEvent.Exit) {
-        output.error("SHELL EXITED. PID: " + _process?.pid + " CODE: " + dataStr);
-        const elapsedSeconds = _startTime
-            ? Math.round((new Date().getTime() - _startTime.getTime()) / 1000)
-            : -1;
-        const outputWithError = _commandOutput.trim() +
-            `\nNAISYS: Command hit time out limit after ${elapsedSeconds} seconds. If possible figure out how to run the command faster or break it up into smaller parts.`;
+        output.error(`SHELL EXIT. PID: ${_process?.pid}, CODE: ${rawDataStr}`);
+        let finalOutput = _currentBufferType == "alternate"
+            ? _getTerminalActiveBuffer()
+            : _commandOutput.trim();
+        finalOutput += `\nNAISYS: Command killed.`;
         resetProcess();
-        _resolveCurrentCommand(outputWithError);
+        _completeCommand(finalOutput);
         return;
     }
-    else {
-        // Extend the timeout of the current command
-        setOrExtendShellTimeout();
+    // Should only happen back in normal mode, so we don't need to modify the rawDataStr
+    let endDelimiterHit = false;
+    const endDelimiterPos = dataStr.indexOf(_commandDelimiter);
+    if (endDelimiterPos != -1 &&
+        // Quotes will only precede the delimiter if the echo command got in the output, so don't count it
+        // For example running nano or vi will cause this
+        dataStr[endDelimiterPos - 1] != '"') {
+        endDelimiterHit = true;
+        dataStr = dataStr.slice(0, endDelimiterPos);
+        // If it does happen somehow, log it so I can figure out why/how and what to do about it
+        if (_currentBufferType == "alternate") {
+            output.error("UNEXPECTED END DELIMITER IN ALTERNATE BUFFER: " + dataStr);
+        }
+    }
+    // If we're in alternate mode, just write the data to the terminal
+    // When the buffer changes back to normal, the output will be copied back to the command output
+    if (_currentBufferType == "normal") {
         _commandOutput += dataStr;
     }
-    const delimiterIndex = _commandOutput.indexOf(_commandDelimiter);
-    if (delimiterIndex != -1) {
-        // trim everything after delimiter
-        _commandOutput = _commandOutput.slice(0, delimiterIndex);
-        const response = _commandOutput.trim();
+    // TODO: get token size of buffer, if too big, switch it front/middle/back
+    _terminal?.write(rawDataStr); // Not synchronous, second param takes a call back, don't need to handle it AFAIK
+    if (endDelimiterHit) {
+        const finalOutput = _commandOutput.trim();
         resetCommand();
-        _resolveCurrentCommand(response);
+        _completeCommand(finalOutput);
     }
 }
 export async function executeCommand(command) {
+    if (_wrapperSuspended) {
+        throw "Use continueCommand to send input to a shell command in process";
+    }
+    command = command.trim();
+    _lastCommand = command; // Set here before it gets reset by the multi line script below
     await ensureOpen();
-    if (_currentPath && command.trim().split("\n").length > 1) {
+    if (_currentPath && command.split("\n").length > 1) {
         command = await putMultilineCommandInAScript(command);
     }
     return new Promise((resolve, reject) => {
         _resolveCurrentCommand = resolve;
-        const commandWithDelimiter = `${command.trim()}\necho "${_commandDelimiter} LINE:\${LINENO}"\n`;
         if (!_process) {
             reject("Shell process is not open");
             return;
         }
+        const commandWithDelimiter = `${command}\necho "${_commandDelimiter}"\n`;
         _process.stdin.write(commandWithDelimiter);
-        _startTime = new Date();
-        // If no response, kill and reset the shell, often hanging on some unescaped input
-        setOrExtendShellTimeout();
+        // Set timeout to wait for response from command
+        setCommandTimeout();
     });
 }
-function setOrExtendShellTimeout() {
-    // Don't extend if we've been waiting longer than the max timeout seconds
-    const timeWaiting = new Date().getTime() - (_startTime?.getTime() || 0);
-    if (!_process?.pid ||
-        timeWaiting > config.shellCommand.maxTimeoutSeconds * 1000) {
-        return;
+/** The LLM made its decision on how it wants to continue with the shell that previously timed out */
+export function continueCommand(command) {
+    if (!_wrapperSuspended) {
+        throw "Shell is not suspended, use execute command";
+    }
+    command = command.trim();
+    _wrapperSuspended = false;
+    let choice;
+    if (command != "wait" && command != "kill") {
+        choice = "input";
+    }
+    else {
+        choice = command;
+    }
+    return new Promise((resolve, reject) => {
+        _resolveCurrentCommand = resolve;
+        // If new output from the shell was queued while waiting for the LLM to decide what to do
+        if (_queuedOutput.length > 0) {
+            for (const output of _queuedOutput) {
+                processOutput(output.rawDataStr, output.eventType, output.pid);
+            }
+            _queuedOutput.length = 0;
+            // If processing queue resolved the command, then we're done
+            if (!_resolveCurrentCommand) {
+                return;
+            }
+            // Used to return here if LLM was sending if output was generated while waiting for the LLM
+            // In normal mode this would make the log confusing and out of order
+            // But since we only use the terminal in alternate mode, this is fine and works
+            // with commands like `mtr` changing the display type
+        }
+        // LLM wants to wait for more output
+        if (choice == "wait") {
+            setCommandTimeout();
+            return;
+        }
+        // Else LLM wants to kill the process
+        else if (choice == "kill") {
+            if (!_currentProcessId) {
+                reject("No process to kill");
+            }
+            else if (resetShell(_currentProcessId)) {
+                return; // Wait for exit event
+            }
+            else {
+                reject("Unable to kill. Process not found");
+            }
+            return;
+        }
+        // Else LLM wants to send input to the process
+        else {
+            if (!_process) {
+                reject("Shell process is not open");
+                return;
+            }
+            _process.stdin.write(command + "\n");
+            _lastCommand = command;
+            setCommandTimeout();
+        }
+    });
+}
+let _startCommandTime;
+/** Pulled out because for commands like 'wait' we want to vary the run time based on the 'last command' */
+let _lastCommand;
+function setCommandTimeout() {
+    _startCommandTime = new Date();
+    let timeoutSeconds = config.shellCommand.timeoutSeconds;
+    if (config.shellCommand.longRunningCommands.some((cmd) => _lastCommand?.startsWith(cmd))) {
+        timeoutSeconds = config.shellCommand.longRunningTimeoutSeconds;
     }
-    // Define the pid for use in the timeout closure, as _process.pid may change
-    const pid = _process.pid;
-    clearTimeout(_currentCommandTimeout);
     _currentCommandTimeout = setTimeout(() => {
-        resetShell(pid);
-    }, config.shellCommand.timeoutSeconds * 1000);
+        returnControlToNaisys();
+    }, timeoutSeconds * 1000);
+}
+function returnControlToNaisys() {
+    _wrapperSuspended = true;
+    _queuedOutput.length = 0;
+    // Flush the output to the consol, and give the LLM instructions of how it might continue
+    let outputWithInstruction = _currentBufferType == "alternate"
+        ? _getTerminalActiveBuffer()
+        : _commandOutput.trim();
+    _commandOutput = "";
+    // Don't clear the alternate buffer, it's a special terminal full screen mode that the
+    // LLM might want to see updates too
+    if (_currentBufferType != "alternate") {
+        resetTerminal();
+    }
+    const waitSeconds = Math.round((new Date().getTime() - _startCommandTime.getTime()) / 1000);
+    outputWithInstruction += `\nNAISYS: Command interrupted after waiting ${waitSeconds} seconds.`;
+    _completeCommand(outputWithInstruction);
 }
 function resetShell(pid) {
     if (!_process || _process.pid != pid) {
         output.comment("Ignoring timeout for old shell process " + pid);
-        return;
+        return false;
     }
-    // There is still an issue here when running on linux where if a command like 'ping' is running
-    // then kill() won't actually kill the 'bash' process hosting the ping, it will just hang here indefinitely
-    // A not fail proof workaround is to tell the LLM to prefix long running commands with 'timeout 10s' or similar
-    const killResponse = _process.kill();
-    output.error(`KILL SIGNAL SENT TO PID: ${_process.pid}, RESPONSE: ${killResponse ? "SUCCESS" : "FAILED"}`);
+    output.error(`KILL-TREE SIGNAL SENT TO PID: ${_process.pid}`);
+    treeKill(pid, "SIGKILL");
     // Should trigger the process close event from here
+    return true;
 }
 export async function getCurrentPath() {
+    // If wrapper suspended just give the last known path
+    if (_wrapperSuspended) {
+        return _currentPath;
+    }
     await ensureOpen();
     _currentPath = await executeCommand("pwd");
     return _currentPath;
@@ -152,18 +260,40 @@ export async function terminate() {
 }
 function resetCommand() {
     _commandOutput = "";
-    _startTime = undefined;
+    resetTerminal();
     clearTimeout(_currentCommandTimeout);
 }
+function resetTerminal() {
+    _bufferChangeEvent?.dispose();
+    _terminal?.dispose();
+    _terminal = new xterm.Terminal({
+        allowProposedApi: true,
+        rows: process.stdout.rows,
+        cols: process.stdout.columns,
+    });
+    _currentBufferType = "normal";
+    _bufferChangeEvent = _terminal.buffer.onBufferChange((buffer) => {
+        // If changing back to normal, copy the alternate buffer back to the output
+        // so it shows up when the command is resolved
+        if (_currentBufferType == "alternate" && buffer.type == "normal") {
+            output.comment("NAISYS: BUFFER CHANGE BACK TO NORMAL");
+            _commandOutput += "\n" + _getTerminalActiveBuffer() + "\n";
+        }
+        _currentBufferType = buffer.type;
+    });
+}
 function resetProcess() {
     resetCommand();
     _process?.removeAllListeners();
     _process = undefined;
+    _terminal?.dispose();
+    _terminal = undefined;
 }
 /** Wraps multi line commands in a script to make it easier to diagnose the source of errors based on line number
  * May also help with common escaping errors */
 function putMultilineCommandInAScript(command) {
-    const scriptPath = new NaisysPath(`${config.naisysFolder}/home/${config.agent.username}/.command.tmp.sh`);
+    const scriptPath = new NaisysPath(`${config.naisysFolder}/agent-data/${config.agent.username}/multiline-command.sh`);
+    pathService.ensureFileDirExists(scriptPath);
     // set -e causes the script to exit on the first error
     const scriptContent = `#!/bin/bash
 set -e
@@ -176,4 +306,32 @@ ${command.trim()}`;
     // `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.getNaisysPath()}`;
 }
+function _completeCommand(output) {
+    if (!_resolveCurrentCommand) {
+        throw "No command to resolve";
+    }
+    _resolveCurrentCommand(output);
+    _resolveCurrentCommand = undefined;
+}
+export function isShellSuspended() {
+    return _wrapperSuspended;
+}
+/**
+ * The alternate/active buffer is a special terminal mode that runs full screen
+ *  independent of the 'normal' buffer that is more like a log
+ */
+function _getTerminalActiveBuffer() {
+    let output = "";
+    const bufferLineCount = _terminal?.buffer.normal?.length || 0;
+    for (let i = 0; i < bufferLineCount; i++) {
+        const line = _terminal?.buffer.alternate
+            ?.getLine(i)
+            ?.translateToString()
+            .trim();
+        if (line) {
+            output += line + "\n";
+        }
+    }
+    return output.trim();
+}
 //# sourceMappingURL=shellWrapper.js.map

package/dist/config.js

@@ -16,13 +16,15 @@ export const shellCommand = {
     outputTokenMax: 3000,
     /** The time NAISYS will wait for new shell output before giving up */
     timeoutSeconds: 15,
-    /** The max time NAISYS will wait for a shell command to complete */
-    maxTimeoutSeconds: 60,
+    /** These commands have their own timeout so the LLM doesn't have to continually waste tokens on wait commands */
+    longRunningCommands: ["nmap", "traceroute", "tracepath", "mtr"],
+    longRunningTimeoutSeconds: 120,
 };
 /** Web pages loaded with llmynx will be reduced down to around this number of tokens */
 export const webTokenMax = 2500;
 export const endSessionEnabled = true;
 export const mailEnabled = true;
+export const webEnabled = true;
 /** Experimental, live updating spot in the context for the LLM to put files, to avoid having to continually cat */
 export const workspacesEnabled = false;
 /** Experimental, allow LLM to trim prompts from it's own session context */

package/dist/features/llmail.js

@@ -19,6 +19,8 @@ async function init() {
     const newDbCreated = await dbUtils.initDatabase(_dbFilePath);
     await usingDatabase(async (db) => {
         if (newDbCreated) {
+            // For llmail to work, the usernames need to be unique
+            // The agentPaths also need to be unique so we know what configuration each agent should use when we restart/reload naisys
             const createTables = [
                 `CREATE TABLE Users (
           id INTEGER PRIMARY KEY, 
@@ -65,16 +67,22 @@ async function init() {
         ]);
         // If user not in database, add them
         if (!user) {
-            const insertedUser = await db.run("INSERT INTO Users (username, title, agentPath, leadUsername) VALUES (?, ?, ?, ?)", [
-                config.agent.username,
-                config.agent.title,
-                config.agent.hostpath,
-                config.agent.leadAgent,
-            ]);
-            if (!insertedUser.lastID) {
-                throw "Error adding local user to llmail database";
+            try {
+                const insertedUser = await db.run("INSERT INTO Users (username, title, agentPath, leadUsername) VALUES (?, ?, ?, ?)", [
+                    config.agent.username,
+                    config.agent.title,
+                    config.agent.hostpath,
+                    config.agent.leadAgent,
+                ]);
+                if (!insertedUser.lastID) {
+                    throw "Error adding local user to llmail database";
+                }
+                _myUserId = insertedUser.lastID;
+            }
+            catch (e) {
+                throw (`A user already exists in the database with the agent path (${config.agent.hostpath})\n` +
+                    `Either create a new agent config file, or delete the ${config.naisysFolder} folder to reset the database.`);
             }
-            _myUserId = insertedUser.lastID;
         }
         // Else already exists, validate it's config path is correct
         else {

package/dist/features/subagent.js

@@ -46,6 +46,7 @@ export async function handleCommand(args) {
     if (!argParams[0]) {
         argParams[0] = "help";
     }
+    let errorText = "";
     switch (argParams[0]) {
         case "help": {
             let helpOutput = `subagent <command>
@@ -75,6 +76,11 @@ export async function handleCommand(args) {
             const newParams = argParams.slice(1).join(" ").split('"');
             const title = newParams[1];
             const task = newParams[3];
+            // Validate title and task set
+            if (!title || !task) {
+                errorText = "See valid 'create' syntax below:\n";
+                break;
+            }
             return await _createAgent(title, task);
         }
         case "start": {
@@ -90,10 +96,11 @@ export async function handleCommand(args) {
             _debugFlushContext(subagentId);
             return "";
         }
-        default:
-            return ("Error, unknown command. See valid commands below:\n" +
-                (await handleCommand("help")));
+        default: {
+            errorText = "Error, unknown command. See valid commands below:\n";
+        }
     }
+    return errorText + (await handleCommand("help"));
 }
 export function getRunningSubagentNames() {
     return _subagents
@@ -112,10 +119,6 @@ export function unreadContextSummary() {
             .join(" | "));
 }
 async function _createAgent(title, taskDescription) {
-    // Validate title and task set
-    if (!title || !taskDescription) {
-        throw "Title and task description must be set";
-    }
     // Get available username
     const usernames = await llmail.getAllUserNames();
     let agentName = "";
@@ -218,6 +221,6 @@ function _debugFlushContext(subagentId) {
     subagent.log = "";
 }
 function _getSubagentDir() {
-    return new NaisysPath(`${config.naisysFolder}/home/${config.agent.username}/.subagents`);
+    return new NaisysPath(`${config.naisysFolder}/agent-data/${config.agent.username}/subagents`);
 }
 //# sourceMappingURL=subagent.js.map

package/dist/llm/llModels.js

@@ -8,7 +8,7 @@ export var LlmApiType;
 const llmModels = [
     {
         key: "gpt4turbo",
-        name: "gpt-4-0125-preview",
+        name: "gpt-4-turbo",
         apiType: LlmApiType.OpenAI,
         maxTokens: 128000,
         // Prices are per 1M tokens
@@ -17,7 +17,7 @@ const llmModels = [
     },
     {
         key: "gpt3turbo",
-        name: "gpt-3.5-turbo-0125",
+        name: "gpt-3.5-turbo",
         apiType: LlmApiType.OpenAI,
         maxTokens: 16000,
         // Prices are per 1M tokens
@@ -49,8 +49,8 @@ const llmModels = [
         apiType: LlmApiType.Google,
         maxTokens: 30720,
         // 60 queries per minute free then the prices below are per 1000 characters
-        inputCost: 0.50,
-        outputCost: 1.50,
+        inputCost: 0.5,
+        outputCost: 1.5,
     },
     {
         key: "claude3opus",

package/dist/llm/llmService.js

@@ -57,8 +57,11 @@ async function sendWithOpenAiCompatible(modelKey, systemMessage, context, source
             })),
         ],
     });
+    if (!model.inputCost && !model.outputCost) {
+        // Don't cost models with no costs
+    }
     // Total up costs, prices are per 1M tokens
-    if (chatResponse.usage) {
+    else if (chatResponse.usage) {
         const cost = chatResponse.usage.prompt_tokens * model.inputCost +
             chatResponse.usage.completion_tokens * model.outputCost;
         await costTracker.recordCost(cost / 1000000, source, model.name);
@@ -118,7 +121,7 @@ async function sendWithGoogle(modelKey, systemMessage, context, source) {
         throw `Google API Request Blocked, ${result.response.promptFeedback.blockReason}`;
     }
     const responseText = result.response.text();
-    // todo: take into account google allows 60 queries per minute for free for 1.0, 2 queries/min for 1.5
+    // TODO: take into account google allows 60 queries per minute for free for 1.0, 2 queries/min for 1.5
     // AFAIK Google API doesn't provide usage data, so we have to estimate it ourselves
     const inputTokenCount = getTokenCount(systemMessage) +
         context

package/dist/llm/systemMessage.js

@@ -18,6 +18,10 @@ let llmailCmd = "";
 if (config.mailEnabled) {
     llmailCmd = `\n  llmail: A local mail system for communicating with your team`;
 }
+let llmynxCmd = "";
+if (config.webEnabled) {
+    llmynxCmd = `\n  llmynx: A context optimized web browser. Enter 'llmynx help' to learn how to use it`;
+}
 let workspaces = "";
 if (config.workspacesEnabled) {
     workspaces = `\nWorkspaces:`;
@@ -71,8 +75,7 @@ LINUX Commands:
   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.
-NAISYS Commands: (cannot be used with other commands on the same prompt)${llmailCmd}${subagentNote}
-  llmynx: A context optimized web browser. Enter 'llmynx help' to learn how to use it${genImgCmd}
+NAISYS Commands: (cannot be used with other commands on the same prompt)${llmailCmd}${subagentNote}${llmynxCmd}${genImgCmd}
   comment "<thought>": Any non-command output like thinking out loud, prefix with the 'comment' command
   pause <seconds>: Pause for <seconds>${trimSession}${endsession}
 Tokens:

package/dist/utils/logService.js

@@ -91,7 +91,7 @@ export function roleToSource(role) {
 }
 /** Write entire context to a file in the users home directory */
 export function recordContext(contextLog) {
-    const filePath = new NaisysPath(`${config.naisysFolder}/home/${config.agent.username}/.current-context.txt`);
+    const filePath = new NaisysPath(`${config.naisysFolder}/agent-data/${config.agent.username}/current-context.txt`);
     pathService.ensureFileDirExists(filePath);
     fs.writeFileSync(filePath.toHostPath(), contextLog);
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "naisys",
   "description": "Node.js Autonomous Intelligence System",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "type": "module",
   "main": "dist/naisys.js",
   "preferGlobal": true,
@@ -9,7 +9,7 @@
     "naisys": "bin/naisys"
   },
   "scripts": {
-    "compile/run/attachable": "tsc && node --inspect dist/naisys.js ./agents/assistant.yaml",
+    "compile/run/attachable": "tsc && node --inspect dist/naisys.js ./agents/netmap.yaml",
     "agent:assistant": "node dist/naisys.js ./agents/assistant.yaml",
     "agent:nightwatch": "node dist/naisys.js ./agents/nightwatch.yaml",
     "clean": "rm -rf dist",
@@ -42,29 +42,32 @@
   "devDependencies": {
     "@types/escape-html": "1.0.4",
     "@types/js-yaml": "4.0.9",
-    "@types/node": "20.12.4",
+    "@types/node": "20.12.7",
     "@types/text-table": "0.2.5",
-    "@typescript-eslint/eslint-plugin": "7.5.0",
-    "@typescript-eslint/parser": "7.5.0",
-    "eslint": "8.57.0",
+    "@typescript-eslint/eslint-plugin": "7.7.0",
+    "@typescript-eslint/parser": "7.7.0",
+    "eslint": "8.56.0",
     "jest": "29.7.0",
     "prettier": "3.2.5",
     "ts-node": "10.9.2",
-    "typescript": "5.4.4"
+    "typescript": "5.4.5"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "0.20.1",
-    "@google/generative-ai": "0.5.0",
+    "@anthropic-ai/sdk": "0.20.5",
+    "@google/generative-ai": "0.7.1",
+    "@xterm/headless": "5.5.0",
     "chalk": "5.3.0",
     "commander": "12.0.0",
     "dotenv": "16.4.5",
     "escape-html": "1.0.3",
     "js-yaml": "4.1.0",
-    "openai": "4.33.0",
+    "openai": "4.36.0",
     "sharp": "0.33.3",
     "sqlite": "5.1.1",
     "sqlite3": "5.1.7",
+    "strip-ansi": "7.1.0",
     "text-table": "0.2.0",
-    "tiktoken": "1.0.13"
+    "tiktoken": "1.0.14",
+    "tree-kill": "1.2.2"
   }
 }