naisys 1.4.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)
 
@@ -73,7 +78,7 @@ dreamModel: claude3opus
 
 # The model to use for llmynx, pre-processing websites to fit into a smaller context (use a cheaper model)
 # defaults to the shellModel if omitted
-webModel: gemini-pro
+webModel: claude3haiku
 
 # The model used by the 'genimg' command. If not defined then the genimg command is not available to the LLM
 # Valid values: dalle2-256, dalle2-512, dalle2-1024, dalle3-1024, dalle3-1024-HD
@@ -112,6 +117,11 @@ spendLimitDollars: 2.00
 #   Auto: All commands are run through the separate LLM instace that will check to see if the command is safe
 commandProtection: "none"
 
+# The max number of subagents allowed to be started and managed. Leave out to disable.
+# Costs by the subagent are applied to the host agent's spend limit
+# Careful: Sub-agents can be chatty, slowing down progress.
+subagentMax: 0
+
 # 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
@@ -169,7 +179,8 @@ initialCommands:
 - NAISYS apps
   - `llmail` - A context friendly 'mail system' used for agent to agent communication
   - `llmynx` - A context friendly wrapping on the lynx browser that can use a separate LLM to reduce the size of a large webpage into something that can fit into the LLM's context
-  - `genimg "<description>" <filepath>` - Generates an image with the given description, save at the specified path
+  - `genimg "<description>" <filepath>` - Generates an image with the given description, save at the specified fully qualified path
+  - `subagent` - A way for LLMs to start/stop their own sub-agents. Communicating with each other with `llmail`. Set the `subagentMax` in the agent config to enable.
 
 ## Running NAISYS from Source
 
@@ -188,16 +199,28 @@ 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
-- If you want to use NAISYS for a website
-  - Install a local web server, for example [XAMPP](https://www.apachefriends.org/) on Windows
-  - Start the server and put the URL 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
+  - PHP for example can start a server with `php -S localhost:8000 -d display_errors=On -d error_reporting=E_ALL`
+- Start the server and put the URL in the `.env` file
 
 ## 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
 - 1.2: Created stand-in shell commands for custom Naisys commands
 - 1.1: Added command protection settings to prevent unwanted writes
-- 1.0: Initial release
+- 1.0: Initial release

package/bin/naisys

@@ -2,18 +2,21 @@
 
 # Make sure to enable this script for execution with `chmod +x naisys`
 
+# Resolves the location of naisys from the bin directory
+SCRIPT=$(readlink -f "$0" || echo "$0")
+SCRIPT_DIR=$(dirname "$SCRIPT")/..
+
 # Check if an argument is provided
 if [ $# -eq 0 ]; then
+  # get version from package.json
+  VERSION=$(node -e "console.log(require('${SCRIPT_DIR}/package.json').version)")
   echo "NAISYS: Node.js Autonomous Intelligence System"
+  echo "  Version: $VERSION"
   echo "  Usage: naisys <path to agent config yaml, or directory>"
   echo "  Note: If a folder is passed then all agents will be started in a tmux session"
   exit 1
 fi
 
-# Resolves the location of naisys from the bin directory
-SCRIPT=$(readlink -f "$0" || echo "$0")
-SCRIPT_DIR=$(dirname "$SCRIPT")/..
-
 # if path is a yaml file then start a single agent
 if [ -f "$1" ]; then
   if [[ "$1" == *".yaml" ]]; then

package/bin/trimsession

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

package/dist/command/commandHandler.js

@@ -1,12 +1,13 @@
 import chalk from "chalk";
-import * as genimg from "../apps/genimg.js";
-import * as llmail from "../apps/llmail.js";
-import * as llmynx from "../apps/llmynx.js";
 import * as config from "../config.js";
+import * as genimg from "../features/genimg.js";
+import * as llmail from "../features/llmail.js";
+import * as llmynx from "../features/llmynx.js";
+import * as subagent from "../features/subagent.js";
 import * as contextManager from "../llm/contextManager.js";
-import { ContentSource } from "../llm/contextManager.js";
 import * as costTracker from "../llm/costTracker.js";
 import * as dreamMaker from "../llm/dreamMaker.js";
+import { ContentSource } from "../llm/llmDtos.js";
 import * as inputMode from "../utils/inputMode.js";
 import { InputMode } from "../utils/inputMode.js";
 import * as output from "../utils/output.js";
@@ -65,7 +66,22 @@ export async function processCommand(prompt, consoleInput) {
                 await contextManager.append("Comment noted. Try running commands now to achieve your goal.");
                 break;
             }
+            case "trimsession": {
+                if (!config.trimSessionEnabled) {
+                    throw 'The "trimsession" command is not enabled in this environment.';
+                }
+                const trimSummary = contextManager.trim(cmdArgs);
+                await contextManager.append(trimSummary);
+                break;
+            }
             case "endsession": {
+                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) {
@@ -105,8 +121,7 @@ export async function processCommand(prompt, consoleInput) {
                 };
             }
             case "cost": {
-                const totalCost = await costTracker.getTotalCosts();
-                output.comment(`Total cost so far $${totalCost.toFixed(2)} of $${config.agent.spendLimitDollars} limit`);
+                await costTracker.printCosts();
                 break;
             }
             case "llmynx": {
@@ -132,20 +147,23 @@ export async function processCommand(prompt, consoleInput) {
                 break;
             }
             case "context":
-                contextManager.printContext();
+                output.comment("#####################");
+                output.comment(contextManager.printContext());
+                output.comment("#####################");
                 break;
+            case "subagent": {
+                const subagentResponse = await subagent.handleCommand(cmdArgs);
+                await contextManager.append(subagentResponse);
+                break;
+            }
             default: {
-                const shellResponse = await shellCommand.handleCommand(input);
-                if (shellResponse.hasErrors && nextInput) {
-                    await output.errorAndLog(`Error detected processing shell command:`);
-                    processNextLLMpromptBlock = false;
-                }
-                nextCommandAction = shellResponse.terminate
+                const exitApp = await shellCommand.handleCommand(input);
+                nextCommandAction = exitApp
                     ? 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}`);
@@ -205,8 +223,18 @@ async function splitMultipleInputCommands(nextInput) {
         }
     }
     // If the LLM forgets the quote on the comment, treat it as a single line comment
+    // Not something we want to use for multi-line commands like llmail and subagent
+    else if (newLinePos > 0 &&
+        (nextInput.startsWith("comment ") ||
+            nextInput.startsWith("genimg ") ||
+            nextInput.startsWith("trimsession "))) {
+        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 &&
-        (nextInput.startsWith("comment ") || nextInput.startsWith("genimg "))) {
+        shellCommand.isShellSuspended() &&
+        (nextInput.startsWith("kill") || nextInput.startsWith("wait"))) {
         input = nextInput.slice(0, newLinePos);
         nextInput = nextInput.slice(newLinePos).trim();
     }

package/dist/command/commandLoop.js

@@ -1,28 +1,31 @@
 import chalk from "chalk";
 import * as readline from "readline";
-import * as llmail from "../apps/llmail.js";
-import * as llmynx from "../apps/llmynx.js";
 import * as config from "../config.js";
+import * as llmail from "../features/llmail.js";
+import * as llmynx from "../features/llmynx.js";
+import * as subagent from "../features/subagent.js";
+import * as workspaces from "../features/workspaces.js";
 import * as contextManager from "../llm/contextManager.js";
-import { ContentSource } from "../llm/contextManager.js";
 import * as dreamMaker from "../llm/dreamMaker.js";
-import { LlmRole } from "../llm/llmDtos.js";
+import { ContentSource, LlmRole } from "../llm/llmDtos.js";
 import * as llmService from "../llm/llmService.js";
+import { systemMessage } from "../llm/systemMessage.js";
 import * as inputMode from "../utils/inputMode.js";
 import { InputMode } from "../utils/inputMode.js";
 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 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
     await output.commentAndLog(`Agent configured to use ${config.agent.shellModel} model`);
     // Show System Message
     await output.commentAndLog("System Message:");
-    const systemMessage = contextManager.getSystemMessage();
     output.write(systemMessage);
     await logService.write({
         role: LlmRole.System,
@@ -31,6 +34,7 @@ export async function run() {
     });
     let nextCommandAction = NextCommandAction.Continue;
     let llmErrorCount = 0;
+    let nextPromptIndex = 0;
     while (nextCommandAction != NextCommandAction.ExitApplication) {
         inputMode.toggle(InputMode.LLM);
         await output.commentAndLog("Starting Context:");
@@ -40,30 +44,37 @@ export async function run() {
             await contextManager.append(latestDream);
         }
         for (const initialCommand of config.agent.initialCommands) {
-            const prompt = await promptBuilder.getPrompt(0, false);
-            await contextManager.append(prompt, ContentSource.ConsolePrompt);
+            let prompt = await promptBuilder.getPrompt(0, false);
+            prompt = setPromptIndex(prompt, ++nextPromptIndex);
+            await contextManager.append(prompt, ContentSource.ConsolePrompt, nextPromptIndex);
             await commandHandler.processCommand(prompt, 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);
+            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
             if (inputMode.current === InputMode.Debug) {
+                subagent.unreadContextSummary();
                 consoleInput = await promptBuilder.getInput(`${prompt}`, pauseSeconds, wakeOnMessage);
             }
             // LLM command prompt
             else if (inputMode.current === InputMode.LLM) {
+                prompt = setPromptIndex(prompt, ++nextPromptIndex);
                 const workingMsg = prompt +
-                    chalk[output.OutputColor.loading](`LLM (${config.agent.shellModel}) Working...`);
+                    chalk[OutputColor.loading](`LLM (${config.agent.shellModel}) Working...`);
                 try {
                     await checkNewMailNotification();
                     await checkContextLimitWarning();
-                    await contextManager.append(prompt, ContentSource.ConsolePrompt);
+                    await workspaces.displayActive();
+                    await contextManager.append(prompt, ContentSource.ConsolePrompt, nextPromptIndex);
                     process.stdout.write(workingMsg);
-                    consoleInput = await llmService.query(config.agent.shellModel, contextManager.getSystemMessage(), contextManager.messages, "console");
+                    consoleInput = await llmService.query(config.agent.shellModel, systemMessage, contextManager.getCombinedMessages(), "console");
                     clearPromptMessage(workingMsg);
                 }
                 catch (e) {
@@ -101,6 +112,7 @@ export async function run() {
             llmynx.clear();
             contextManager.clear();
             nextCommandAction = NextCommandAction.Continue;
+            nextPromptIndex = 0;
         }
     }
 }
@@ -178,7 +190,7 @@ async function checkNewMailNotification() {
         for (const unreadThread of unreadThreads) {
             await llmail.markAsRead(unreadThread.threadId);
         }
-        mailBlackoutCountdown = config.mailBlackoutCycles;
+        mailBlackoutCountdown = config.agent.mailBlackoutCycles || 0;
     }
     else if (llmail.simpleMode) {
         await contextManager.append(`You have new mail, but not enough context to read them.\n` +
@@ -196,11 +208,34 @@ async function checkContextLimitWarning() {
     const tokenCount = contextManager.getTokenCount();
     const tokenMax = config.agent.tokenMax;
     if (tokenCount > tokenMax) {
-        await contextManager.append(`The token limit for this session has been exceeded.
-Use \`endsession <note>\` to clear the console and reset the session.
+        let tokenNote = "";
+        if (config.endSessionEnabled) {
+            tokenNote += `\nUse 'endsession <note>' to clear the console and reset the session.
   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.`, ContentSource.Console);
+  The note should contain your next goal, and important things should you remember.`;
+        }
+        if (config.trimSessionEnabled) {
+            tokenNote += `\nUse 'trimsession' to reduce the size of the session.
+  Use comments to remember important things from trimmed prompts.`;
+        }
+        await contextManager.append(`The token limit for this session has been exceeded.${tokenNote}`, ContentSource.Console);
+    }
+}
+/** Insert prompt index [Index: 1] before the $.
+ * Insert at the end of the prompt so that 'prompt splitting' still works in the command handler
+ */
+function setPromptIndex(prompt, index) {
+    if (!config.trimSessionEnabled) {
+        return prompt;
+    }
+    let newPrompt = prompt;
+    const endPromptPos = prompt.lastIndexOf("$");
+    if (endPromptPos != -1) {
+        newPrompt =
+            prompt.slice(0, endPromptPos) +
+                ` [Index: ${index}]` +
+                prompt.slice(endPromptPos);
     }
+    return newPrompt;
 }
 //# sourceMappingURL=commandLoop.js.map

package/dist/command/promptBuilder.js

@@ -1,34 +1,42 @@
 import chalk from "chalk";
 import * as events from "events";
 import * as readline from "readline";
-import * as llmail from "../apps/llmail.js";
 import * as config from "../config.js";
+import * as llmail from "../features/llmail.js";
 import * as contextManager from "../llm/contextManager.js";
 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;
@@ -59,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;
@@ -91,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
@@ -132,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,54 +4,55 @@ 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(" ");
-    const response = {
-        hasErrors: true,
-    };
-    // 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])) {
-        await contextManager.append(`${cmdParams[0]} not supported. Use \`cat\` to read a file and \`cat > filename << 'EOF'\` to write a file`);
-        return response;
-    }
-    if (cmdParams[0] == "lynx" && cmdParams[1] != "--dump") {
-        await contextManager.append(`Interactive mode with lynx is not supported. Use --dump with lynx to view a website`);
-        return response;
-    }
-    if (cmdParams[0] == "exit") {
-        if (inputMode.current == InputMode.LLM) {
-            await contextManager.append("Use 'endsession' to end the session and clear the console log.");
-        }
-        else if (inputMode.current == InputMode.Debug) {
-            await shellWrapper.terminate();
-            response.terminate = true;
-        }
-        return response;
-    }
-    const output = await shellWrapper.executeCommand(input);
-    if (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);
+    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`;
         }
-        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.`);
+        if (cmdParams[0] == "lynx" && cmdParams[1] != "--dump") {
+            throw `Interactive mode with lynx is not supported. Use --dump with lynx to view a website`;
         }
-        if (text.endsWith(": command not found")) {
-            await contextManager.append("Please enter a valid Linux or NAISYS command after the prompt. Use the 'comment' command for thoughts.");
+        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 outputLimitExceeded = false;
+    const tokenCount = utilities.getTokenCount(response);
+    // Prevent too much output from blowing up the context
+    if (tokenCount > config.shellCommand.outputTokenMax) {
+        outputLimitExceeded = true;
+        const trimLength = (response.length * config.shellCommand.outputTokenMax) / tokenCount;
+        response =
+            response.slice(0, trimLength / 2) +
+                "\n\n...\n\n" +
+                response.slice(-trimLength / 2);
+    }
+    if (outputLimitExceeded) {
+        response += `\nThe shell command generated too much output (${tokenCount} tokens). Only 2,000 tokens worth are shown above.`;
+    }
+    if (response.endsWith(": command not found")) {
+        response +=
+            "\nPlease enter a valid Linux or NAISYS command after the prompt. Use the 'comment' command for thoughts.";
     }
-    response.hasErrors = output.hasErrors;
-    return response;
+    // TODO: move this into the command handler to remove the context manager dependency
+    await contextManager.append(response);
+    return false;
 }
 //# sourceMappingURL=shellCommand.js.map