naisys 1.4.0 → 1.5.0

package/README.md

@@ -73,7 +73,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 +112,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 +174,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
 
@@ -190,14 +196,18 @@ initialCommands:
 - Install WSL (Windows Subsystem for Linux)
 - 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
+
+#### 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.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,18 @@ 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.';
+                }
                 // 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 +117,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,15 +143,18 @@ 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;
             }
@@ -205,8 +219,11 @@ 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("comment ") ||
+            nextInput.startsWith("genimg ") ||
+            nextInput.startsWith("trimsession "))) {
         input = nextInput.slice(0, newLinePos);
         nextInput = nextInput.slice(newLinePos).trim();
     }

package/dist/command/commandLoop.js

@@ -1,17 +1,20 @@
 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";
@@ -22,7 +25,6 @@ export async function run() {
     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 +33,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 +43,34 @@ 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);
+            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 +108,7 @@ export async function run() {
             llmynx.clear();
             contextManager.clear();
             nextCommandAction = NextCommandAction.Continue;
+            nextPromptIndex = 0;
         }
     }
 }
@@ -178,7 +186,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 +204,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,8 +1,8 @@
 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";
@@ -17,6 +17,7 @@ const _outputEmitter = new events.EventEmitter();
 const _originalWrite = process.stdout.write.bind(process.stdout);
 process.stdout.write = (...args) => {
     _outputEmitter.emit(_writeEventName, false, ...args);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return _originalWrite.apply(process.stdout, args);
 };
 const _readlineInterface = readline.createInterface({

package/dist/command/shellCommand.js

@@ -6,52 +6,45 @@ import * as utilities from "../utils/utilities.js";
 import * as shellWrapper from "./shellWrapper.js";
 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;
+        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") {
-        await contextManager.append(`Interactive mode with lynx is not supported. Use --dump with lynx to view a website`);
-        return response;
+        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) {
-            await contextManager.append("Use 'endsession' to end the session and clear the console log.");
+            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();
-            response.terminate = true;
+            return 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);
-        }
-        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 (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.");
-        }
+    let response = await shellWrapper.executeCommand(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 +=
+            "Please 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

package/dist/command/shellWrapper.js

@@ -3,7 +3,7 @@ import * as fs from "fs";
 import * as os from "os";
 import * as config from "../config.js";
 import * as output from "../utils/output.js";
-import { unixToHostPath } from "../utils/utilities.js";
+import { NaisysPath } from "../utils/pathService.js";
 var ShellEvent;
 (function (ShellEvent) {
     ShellEvent["Ouptput"] = "stdout";
@@ -11,39 +11,43 @@ var ShellEvent;
     ShellEvent["Exit"] = "exit";
 })(ShellEvent || (ShellEvent = {}));
 let _process;
-//let _log = "";
+let _currentProcessId;
 let _commandOutput = "";
-let _hasErrors = false;
 let _currentPath;
 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__";
 async function ensureOpen() {
     if (_process) {
         return;
     }
-    //_log = "";
     resetCommand();
     const spawnProcess = os.platform() === "win32" ? "wsl" : "bash";
     _process = spawn(spawnProcess, [], { 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);
+        processOutput(data.toString(), ShellEvent.Ouptput, pid);
     });
     _process.stderr.on("data", (data) => {
-        processOutput(data.toString(), ShellEvent.Error);
+        processOutput(data.toString(), ShellEvent.Error, pid);
     });
     _process.on("close", (code) => {
-        processOutput(`${code}`, ShellEvent.Exit);
-        _process = undefined;
+        processOutput(`${code}`, ShellEvent.Exit, pid);
     });
     // 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);
+        output.comment("NEW SHELL OPENED. PID: " + pid);
         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);
+        output.comment("SHELL RESTORED. PID: " + pid);
         errorIfNotEmpty(await executeCommand("cd " + _currentPath));
     }
     // Stop running commands if one fails
@@ -53,102 +57,92 @@ async function ensureOpen() {
 }
 /** Basically don't show anything in the console unless there is an error */
 function errorIfNotEmpty(response) {
-    if (response.value) {
-        output.error(response.value);
+    if (response) {
+        output.error(response);
     }
 }
-function processOutput(dataStr, eventType) {
+function processOutput(dataStr, eventType, pid) {
+    if (pid != _currentProcessId) {
+        output.comment(`Ignoring '${eventType}' from old shell process ${pid}: ` + dataStr);
+        return;
+    }
     if (!_resolveCurrentCommand) {
-        output.comment(eventType + " without handler: " + dataStr);
+        output.comment(`Ignoring '${eventType}' from process ${pid} with no resolve handler: ` +
+            dataStr);
         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.`;
+        resetProcess();
+        _resolveCurrentCommand(outputWithError);
+        return;
     }
     else {
-        //_log += "OUTPUT: " + dataStr;
+        // Extend the timeout of the current command
+        setOrExtendShellTimeout();
         _commandOutput += dataStr;
     }
-    if (eventType === ShellEvent.Error) {
-        _hasErrors = true;
-        //output += "stderr: ";
-        // parse out the line number from '-bash: line 999: '
-        /*if (dataStr.startsWith("-bash: line ")) {
-          output.error(dataStr);
-    
-          const lineNum = dataStr.slice(11, dataStr.indexOf(": ", 11));
-          output.error(`Detected error on line ${lineNum} of output`);
-    
-          // display the same line of _output
-          const logLines = _log.split("\n");
-          const lineIndex = parseInt(lineNum) - 1;
-          if (logLines.length > lineIndex) {
-            output.error(`Line ${lineIndex} in log: ` + logLines[lineIndex]);
-          }
-    
-          // output all lines for debugging
-          for (let i = 0; i < logLines.length; i++) {
-            // if withing 10 lines of the error, show the line
-            //if (Math.abs(i - lineIndex) < 10) {
-              const lineStr = logLines[i].replace(/\n/g, "");
-              output.error(`${i}: ${lineStr}`);
-            //}
-          }
-        }*/
-    }
     const delimiterIndex = _commandOutput.indexOf(_commandDelimiter);
-    if (delimiterIndex != -1 || eventType === ShellEvent.Exit) {
+    if (delimiterIndex != -1) {
         // trim everything after delimiter
         _commandOutput = _commandOutput.slice(0, delimiterIndex);
-        const response = {
-            value: _commandOutput.trim(),
-            hasErrors: _hasErrors,
-        };
+        const response = _commandOutput.trim();
         resetCommand();
         _resolveCurrentCommand(response);
     }
 }
 export async function executeCommand(command) {
-    /*if (command == "shelllog") {
-      _log.split("\n").forEach((line, i) => {
-        output.comment(`${i}. ${line}`);
-      });
-  
-      return <CommandResponse>{
-        value: "",
-        hasErrors: false,
-      };
-    }*/
     await ensureOpen();
     if (_currentPath && command.trim().split("\n").length > 1) {
-        command = await runCommandFromScript(command);
+        command = await putMultilineCommandInAScript(command);
     }
-    return new Promise((resolve) => {
+    return new Promise((resolve, reject) => {
         _resolveCurrentCommand = resolve;
         const commandWithDelimiter = `${command.trim()}\necho "${_commandDelimiter} LINE:\${LINENO}"\n`;
-        //_log += "INPUT: " + commandWithDelimiter;
-        _process?.stdin.write(commandWithDelimiter);
+        if (!_process) {
+            reject("Shell process is not open");
+            return;
+        }
+        _process.stdin.write(commandWithDelimiter);
+        _startTime = new Date();
         // If no response, kill and reset the shell, often hanging on some unescaped input
-        _currentCommandTimeout = setTimeout(resetShell, config.shellCommmandTimeoutSeconds * 1000);
+        setOrExtendShellTimeout();
     });
 }
-function resetShell() {
-    if (!_resolveCurrentCommand) {
+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;
     }
-    _process?.kill();
-    output.error("SHELL TIMEMOUT/KILLED. PID: " + _process?.pid);
-    const outputWithError = _commandOutput.trim() +
-        `\nError: Command timed out after ${config.shellCommmandTimeoutSeconds} seconds.`;
-    resetProcess();
-    _resolveCurrentCommand({
-        value: outputWithError,
-        hasErrors: true,
-    });
+    // 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);
+}
+function resetShell(pid) {
+    if (!_process || _process.pid != pid) {
+        output.comment("Ignoring timeout for old shell process " + pid);
+        return;
+    }
+    // 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"}`);
+    // Should trigger the process close event from here
 }
 export async function getCurrentPath() {
     await ensureOpen();
-    _currentPath = (await executeCommand("pwd")).value;
+    _currentPath = await executeCommand("pwd");
     return _currentPath;
 }
 export async function terminate() {
@@ -158,7 +152,7 @@ export async function terminate() {
 }
 function resetCommand() {
     _commandOutput = "";
-    _hasErrors = false;
+    _startTime = undefined;
     clearTimeout(_currentCommandTimeout);
 }
 function resetProcess() {
@@ -168,18 +162,18 @@ function resetProcess() {
 }
 /** 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 runCommandFromScript(command) {
-    const scriptPath = `${config.naisysFolder}/home/${config.agent.username}/.command.tmp.sh`;
+function putMultilineCommandInAScript(command) {
+    const scriptPath = new NaisysPath(`${config.naisysFolder}/home/${config.agent.username}/.command.tmp.sh`);
     // 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(unixToHostPath(scriptPath), scriptContent);
+    // create/write file
+    fs.writeFileSync(scriptPath.toHostPath(), scriptContent);
     // `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}`;
+    return `PATH=${config.binPath}:$PATH source ${scriptPath.getNaisysPath()}`;
 }
 //# sourceMappingURL=shellWrapper.js.map