amai 0.0.2 → 0.0.4

package/dist/cli.cjs

@@ -3,6 +3,7 @@
 
 var pc4 = require('picocolors');
 var WebSocket = require('ws');
+var events = require('events');
 var zod = require('zod');
 var promises = require('fs/promises');
 var path9 = require('path');
@@ -1261,10 +1262,50 @@ var startHttpServer = (connection) => {
   }
   const app = new hono.Hono();
   app.use(cors.cors());
-  app.post("/daemon/status/stream", (c) => {
+  app.post("/daemon/status", (c) => {
     const status = wsConnection ? getConnectionStatus(wsConnection) : "closed";
     return c.json({ connected: status === "open" });
   });
+  app.get("/daemon/status/stream", (c) => {
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+      start(controller) {
+        const initialStatus = wsConnection ? getConnectionStatus(wsConnection) : "closed";
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ connected: initialStatus === "open" })}
+
+`));
+        const statusHandler = (data) => {
+          try {
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
+
+`));
+          } catch {
+          }
+        };
+        statusEmitter.on("status", statusHandler);
+        const heartbeatInterval = setInterval(() => {
+          try {
+            const currentStatus = wsConnection ? getConnectionStatus(wsConnection) : "closed";
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify({ connected: currentStatus === "open" })}
+
+`));
+          } catch {
+          }
+        }, 15e3);
+        c.req.raw.signal.addEventListener("abort", () => {
+          statusEmitter.off("status", statusHandler);
+          clearInterval(heartbeatInterval);
+        });
+      }
+    });
+    return new Response(stream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive"
+      }
+    });
+  });
   app.get("context", async (c) => {
     const context = getContext(process.cwd());
     return c.body(JSON.stringify(context));
@@ -1506,8 +1547,96 @@ async function login() {
     throw error;
   }
 }
+var ExplanationSchema = zod.z.object({
+  explanation: zod.z.string().describe("One sentence explanation as to why this tool is being used")
+});
+zod.z.object({
+  command: zod.z.string().describe("The terminal command to execute"),
+  is_background: zod.z.boolean().describe("Whether the command should be run in the background")
+}).merge(ExplanationSchema);
+var runSecureTerminalCommand = async (command, timeout) => {
+  try {
+    return new Promise((resolve, reject) => {
+      const child = child_process.spawn(command, {
+        cwd: process.cwd(),
+        stdio: ["pipe", "pipe", "pipe"],
+        shell: true
+      });
+      let stdout = "";
+      let stderr = "";
+      let timeoutId = null;
+      if (timeoutId > 0) {
+        timeoutId = setTimeout(() => {
+          child.kill("SIGKILL");
+          reject(new Error(`Command timed out after ${timeout}ms`));
+        }, timeout);
+      }
+      child.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+      child.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      child.stdout.on("close", (code) => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        resolve({ stdout, stderr, exitCode: code || 0 });
+      });
+      child.stderr.on("error", (error) => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        reject(error);
+      });
+    });
+  } catch {
+    console.error("Error while ecexuting the securedShell command");
+  }
+};
+var runTerminalCommand = async (input, projectCwd) => {
+  try {
+    if (input?.is_background) {
+      const child = child_process.spawn(input.command, {
+        cwd: projectCwd,
+        detached: true,
+        stdio: "ignore",
+        shell: true
+      });
+      child.unref();
+      console.log(`[LOCAL] Background command started: ${input.command}`);
+      return {
+        success: true,
+        message: `Background command started: ${input.command}`,
+        isBackground: true
+      };
+    } else {
+      const result = await runSecureTerminalCommand(
+        input.command,
+        3e4
+        // 30 second timeout
+      );
+      const success = result?.exitCode === 0;
+      return {
+        success,
+        stdout: result?.stdout?.trim(),
+        stderr: result?.stderr?.trim(),
+        exitCode: result?.exitCode,
+        message: success ? `Command executed successfully: ${input.command}` : `Command failed with exit code ${result?.exitCode}: ${input.command}`
+      };
+    }
+  } catch (error) {
+    console.error("Error while executing the terminal command", error);
+    return {
+      success: false,
+      message: "Error while executing the terminal command",
+      error: error.message
+    };
+  }
+};
 
 // src/server.ts
+var statusEmitter = new events.EventEmitter();
 var toolExecutors = {
   editFile: editFiles,
   deleteFile,
@@ -1515,7 +1644,8 @@ var toolExecutors = {
   glob: globTool,
   listDirectory: list,
   readFile: read_file,
-  stringReplace: apply_patch
+  stringReplace: apply_patch,
+  runTerminalCommand
 };
 function getConnectionStatus(ws) {
   return ws.readyState === WebSocket__default.default.CONNECTING ? "connecting" : ws.readyState === WebSocket__default.default.OPEN ? "open" : ws.readyState === WebSocket__default.default.CLOSING ? "closing" : "closed";
@@ -1533,6 +1663,7 @@ function connectToServer2(serverUrl = DEFAULT_SERVER_URL) {
   });
   ws.on("open", () => {
     console.log(pc4__default.default.green("Connected to server agent streams"));
+    statusEmitter.emit("status", { connected: true });
   });
   ws.on("message", async (data) => {
     const message = JSON.parse(data.toString());
@@ -1562,10 +1693,12 @@ function connectToServer2(serverUrl = DEFAULT_SERVER_URL) {
   });
   ws.on("close", () => {
     console.log(pc4__default.default.red("Disconnected from server. Reconnecting in 5s..."));
+    statusEmitter.emit("status", { connected: false });
     setTimeout(() => connectToServer2(serverUrl), 5e3);
   });
   ws.on("error", (error) => {
     console.error(pc4__default.default.red(`WebSocket error: ${error.message}`));
+    statusEmitter.emit("status", { connected: false });
   });
   return ws;
 }
@@ -1762,7 +1895,7 @@ function getDaemonPid() {
     return null;
   }
 }
-var VERSION = "0.0.2";
+var VERSION = "0.0.4";
 var PROJECT_DIR = process.cwd();
 function promptUser(question) {
   const rl = readline__default.default.createInterface({

package/dist/cli.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import pc4 from 'picocolors';
 import WebSocket from 'ws';
+import { EventEmitter } from 'events';
 import { z } from 'zod';
 import { readFile, writeFile, stat, access, readdir, glob, unlink, mkdir } from 'fs/promises';
 import path9, { dirname } from 'path';
@@ -1249,10 +1250,50 @@ var startHttpServer = (connection) => {
   }
   const app = new Hono();
   app.use(cors());
-  app.post("/daemon/status/stream", (c) => {
+  app.post("/daemon/status", (c) => {
     const status = wsConnection ? getConnectionStatus(wsConnection) : "closed";
     return c.json({ connected: status === "open" });
   });
+  app.get("/daemon/status/stream", (c) => {
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+      start(controller) {
+        const initialStatus = wsConnection ? getConnectionStatus(wsConnection) : "closed";
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ connected: initialStatus === "open" })}
+
+`));
+        const statusHandler = (data) => {
+          try {
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
+
+`));
+          } catch {
+          }
+        };
+        statusEmitter.on("status", statusHandler);
+        const heartbeatInterval = setInterval(() => {
+          try {
+            const currentStatus = wsConnection ? getConnectionStatus(wsConnection) : "closed";
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify({ connected: currentStatus === "open" })}
+
+`));
+          } catch {
+          }
+        }, 15e3);
+        c.req.raw.signal.addEventListener("abort", () => {
+          statusEmitter.off("status", statusHandler);
+          clearInterval(heartbeatInterval);
+        });
+      }
+    });
+    return new Response(stream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive"
+      }
+    });
+  });
   app.get("context", async (c) => {
     const context = getContext(process.cwd());
     return c.body(JSON.stringify(context));
@@ -1494,8 +1535,96 @@ async function login() {
     throw error;
   }
 }
+var ExplanationSchema = z.object({
+  explanation: z.string().describe("One sentence explanation as to why this tool is being used")
+});
+z.object({
+  command: z.string().describe("The terminal command to execute"),
+  is_background: z.boolean().describe("Whether the command should be run in the background")
+}).merge(ExplanationSchema);
+var runSecureTerminalCommand = async (command, timeout) => {
+  try {
+    return new Promise((resolve, reject) => {
+      const child = spawn(command, {
+        cwd: process.cwd(),
+        stdio: ["pipe", "pipe", "pipe"],
+        shell: true
+      });
+      let stdout = "";
+      let stderr = "";
+      let timeoutId = null;
+      if (timeoutId > 0) {
+        timeoutId = setTimeout(() => {
+          child.kill("SIGKILL");
+          reject(new Error(`Command timed out after ${timeout}ms`));
+        }, timeout);
+      }
+      child.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+      child.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      child.stdout.on("close", (code) => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        resolve({ stdout, stderr, exitCode: code || 0 });
+      });
+      child.stderr.on("error", (error) => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        reject(error);
+      });
+    });
+  } catch {
+    console.error("Error while ecexuting the securedShell command");
+  }
+};
+var runTerminalCommand = async (input, projectCwd) => {
+  try {
+    if (input?.is_background) {
+      const child = spawn(input.command, {
+        cwd: projectCwd,
+        detached: true,
+        stdio: "ignore",
+        shell: true
+      });
+      child.unref();
+      console.log(`[LOCAL] Background command started: ${input.command}`);
+      return {
+        success: true,
+        message: `Background command started: ${input.command}`,
+        isBackground: true
+      };
+    } else {
+      const result = await runSecureTerminalCommand(
+        input.command,
+        3e4
+        // 30 second timeout
+      );
+      const success = result?.exitCode === 0;
+      return {
+        success,
+        stdout: result?.stdout?.trim(),
+        stderr: result?.stderr?.trim(),
+        exitCode: result?.exitCode,
+        message: success ? `Command executed successfully: ${input.command}` : `Command failed with exit code ${result?.exitCode}: ${input.command}`
+      };
+    }
+  } catch (error) {
+    console.error("Error while executing the terminal command", error);
+    return {
+      success: false,
+      message: "Error while executing the terminal command",
+      error: error.message
+    };
+  }
+};
 
 // src/server.ts
+var statusEmitter = new EventEmitter();
 var toolExecutors = {
   editFile: editFiles,
   deleteFile,
@@ -1503,7 +1632,8 @@ var toolExecutors = {
   glob: globTool,
   listDirectory: list,
   readFile: read_file,
-  stringReplace: apply_patch
+  stringReplace: apply_patch,
+  runTerminalCommand
 };
 function getConnectionStatus(ws) {
   return ws.readyState === WebSocket.CONNECTING ? "connecting" : ws.readyState === WebSocket.OPEN ? "open" : ws.readyState === WebSocket.CLOSING ? "closing" : "closed";
@@ -1521,6 +1651,7 @@ function connectToServer2(serverUrl = DEFAULT_SERVER_URL) {
   });
   ws.on("open", () => {
     console.log(pc4.green("Connected to server agent streams"));
+    statusEmitter.emit("status", { connected: true });
   });
   ws.on("message", async (data) => {
     const message = JSON.parse(data.toString());
@@ -1550,10 +1681,12 @@ function connectToServer2(serverUrl = DEFAULT_SERVER_URL) {
   });
   ws.on("close", () => {
     console.log(pc4.red("Disconnected from server. Reconnecting in 5s..."));
+    statusEmitter.emit("status", { connected: false });
     setTimeout(() => connectToServer2(serverUrl), 5e3);
   });
   ws.on("error", (error) => {
     console.error(pc4.red(`WebSocket error: ${error.message}`));
+    statusEmitter.emit("status", { connected: false });
   });
   return ws;
 }
@@ -1750,7 +1883,7 @@ function getDaemonPid() {
     return null;
   }
 }
-var VERSION = "0.0.2";
+var VERSION = "0.0.4";
 var PROJECT_DIR = process.cwd();
 function promptUser(question) {
   const rl = readline.createInterface({

package/dist/lib/daemon-entry.cjs

@@ -2,6 +2,7 @@
 'use strict';
 
 var WebSocket = require('ws');
+var events = require('events');
 var zod = require('zod');
 var promises = require('fs/promises');
 var path9 = require('path');
@@ -1256,10 +1257,50 @@ var startHttpServer = (connection) => {
   }
   const app = new hono.Hono();
   app.use(cors.cors());
-  app.post("/daemon/status/stream", (c) => {
+  app.post("/daemon/status", (c) => {
     const status = wsConnection ? getConnectionStatus(wsConnection) : "closed";
     return c.json({ connected: status === "open" });
   });
+  app.get("/daemon/status/stream", (c) => {
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+      start(controller) {
+        const initialStatus = wsConnection ? getConnectionStatus(wsConnection) : "closed";
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ connected: initialStatus === "open" })}
+
+`));
+        const statusHandler = (data) => {
+          try {
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
+
+`));
+          } catch {
+          }
+        };
+        statusEmitter.on("status", statusHandler);
+        const heartbeatInterval = setInterval(() => {
+          try {
+            const currentStatus = wsConnection ? getConnectionStatus(wsConnection) : "closed";
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify({ connected: currentStatus === "open" })}
+
+`));
+          } catch {
+          }
+        }, 15e3);
+        c.req.raw.signal.addEventListener("abort", () => {
+          statusEmitter.off("status", statusHandler);
+          clearInterval(heartbeatInterval);
+        });
+      }
+    });
+    return new Response(stream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive"
+      }
+    });
+  });
   app.get("context", async (c) => {
     const context = getContext(process.cwd());
     return c.body(JSON.stringify(context));
@@ -1361,8 +1402,96 @@ function getTokens() {
   const data = JSON.parse(raw);
   return data;
 }
+var ExplanationSchema = zod.z.object({
+  explanation: zod.z.string().describe("One sentence explanation as to why this tool is being used")
+});
+zod.z.object({
+  command: zod.z.string().describe("The terminal command to execute"),
+  is_background: zod.z.boolean().describe("Whether the command should be run in the background")
+}).merge(ExplanationSchema);
+var runSecureTerminalCommand = async (command, timeout) => {
+  try {
+    return new Promise((resolve, reject) => {
+      const child = child_process.spawn(command, {
+        cwd: process.cwd(),
+        stdio: ["pipe", "pipe", "pipe"],
+        shell: true
+      });
+      let stdout = "";
+      let stderr = "";
+      let timeoutId = null;
+      if (timeoutId > 0) {
+        timeoutId = setTimeout(() => {
+          child.kill("SIGKILL");
+          reject(new Error(`Command timed out after ${timeout}ms`));
+        }, timeout);
+      }
+      child.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+      child.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      child.stdout.on("close", (code) => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        resolve({ stdout, stderr, exitCode: code || 0 });
+      });
+      child.stderr.on("error", (error) => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        reject(error);
+      });
+    });
+  } catch {
+    console.error("Error while ecexuting the securedShell command");
+  }
+};
+var runTerminalCommand = async (input, projectCwd) => {
+  try {
+    if (input?.is_background) {
+      const child = child_process.spawn(input.command, {
+        cwd: projectCwd,
+        detached: true,
+        stdio: "ignore",
+        shell: true
+      });
+      child.unref();
+      console.log(`[LOCAL] Background command started: ${input.command}`);
+      return {
+        success: true,
+        message: `Background command started: ${input.command}`,
+        isBackground: true
+      };
+    } else {
+      const result = await runSecureTerminalCommand(
+        input.command,
+        3e4
+        // 30 second timeout
+      );
+      const success = result?.exitCode === 0;
+      return {
+        success,
+        stdout: result?.stdout?.trim(),
+        stderr: result?.stderr?.trim(),
+        exitCode: result?.exitCode,
+        message: success ? `Command executed successfully: ${input.command}` : `Command failed with exit code ${result?.exitCode}: ${input.command}`
+      };
+    }
+  } catch (error) {
+    console.error("Error while executing the terminal command", error);
+    return {
+      success: false,
+      message: "Error while executing the terminal command",
+      error: error.message
+    };
+  }
+};
 
 // src/server.ts
+var statusEmitter = new events.EventEmitter();
 var toolExecutors = {
   editFile: editFiles,
   deleteFile,
@@ -1370,7 +1499,8 @@ var toolExecutors = {
   glob: globTool,
   listDirectory: list,
   readFile: read_file,
-  stringReplace: apply_patch
+  stringReplace: apply_patch,
+  runTerminalCommand
 };
 function getConnectionStatus(ws) {
   return ws.readyState === WebSocket__default.default.CONNECTING ? "connecting" : ws.readyState === WebSocket__default.default.OPEN ? "open" : ws.readyState === WebSocket__default.default.CLOSING ? "closing" : "closed";
@@ -1388,6 +1518,7 @@ function connectToServer2(serverUrl = DEFAULT_SERVER_URL) {
   });
   ws.on("open", () => {
     console.log(pc2__default.default.green("Connected to server agent streams"));
+    statusEmitter.emit("status", { connected: true });
   });
   ws.on("message", async (data) => {
     const message = JSON.parse(data.toString());
@@ -1417,10 +1548,12 @@ function connectToServer2(serverUrl = DEFAULT_SERVER_URL) {
   });
   ws.on("close", () => {
     console.log(pc2__default.default.red("Disconnected from server. Reconnecting in 5s..."));
+    statusEmitter.emit("status", { connected: false });
     setTimeout(() => connectToServer2(serverUrl), 5e3);
   });
   ws.on("error", (error) => {
     console.error(pc2__default.default.red(`WebSocket error: ${error.message}`));
+    statusEmitter.emit("status", { connected: false });
   });
   return ws;
 }

package/dist/lib/daemon-entry.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import WebSocket from 'ws';
+import { EventEmitter } from 'events';
 import { z } from 'zod';
 import { readFile, writeFile, stat, access, readdir, glob, unlink, mkdir } from 'fs/promises';
 import path9 from 'path';
@@ -1246,10 +1247,50 @@ var startHttpServer = (connection) => {
   }
   const app = new Hono();
   app.use(cors());
-  app.post("/daemon/status/stream", (c) => {
+  app.post("/daemon/status", (c) => {
     const status = wsConnection ? getConnectionStatus(wsConnection) : "closed";
     return c.json({ connected: status === "open" });
   });
+  app.get("/daemon/status/stream", (c) => {
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+      start(controller) {
+        const initialStatus = wsConnection ? getConnectionStatus(wsConnection) : "closed";
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ connected: initialStatus === "open" })}
+
+`));
+        const statusHandler = (data) => {
+          try {
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
+
+`));
+          } catch {
+          }
+        };
+        statusEmitter.on("status", statusHandler);
+        const heartbeatInterval = setInterval(() => {
+          try {
+            const currentStatus = wsConnection ? getConnectionStatus(wsConnection) : "closed";
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify({ connected: currentStatus === "open" })}
+
+`));
+          } catch {
+          }
+        }, 15e3);
+        c.req.raw.signal.addEventListener("abort", () => {
+          statusEmitter.off("status", statusHandler);
+          clearInterval(heartbeatInterval);
+        });
+      }
+    });
+    return new Response(stream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive"
+      }
+    });
+  });
   app.get("context", async (c) => {
     const context = getContext(process.cwd());
     return c.body(JSON.stringify(context));
@@ -1351,8 +1392,96 @@ function getTokens() {
   const data = JSON.parse(raw);
   return data;
 }
+var ExplanationSchema = z.object({
+  explanation: z.string().describe("One sentence explanation as to why this tool is being used")
+});
+z.object({
+  command: z.string().describe("The terminal command to execute"),
+  is_background: z.boolean().describe("Whether the command should be run in the background")
+}).merge(ExplanationSchema);
+var runSecureTerminalCommand = async (command, timeout) => {
+  try {
+    return new Promise((resolve, reject) => {
+      const child = spawn(command, {
+        cwd: process.cwd(),
+        stdio: ["pipe", "pipe", "pipe"],
+        shell: true
+      });
+      let stdout = "";
+      let stderr = "";
+      let timeoutId = null;
+      if (timeoutId > 0) {
+        timeoutId = setTimeout(() => {
+          child.kill("SIGKILL");
+          reject(new Error(`Command timed out after ${timeout}ms`));
+        }, timeout);
+      }
+      child.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+      child.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      child.stdout.on("close", (code) => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        resolve({ stdout, stderr, exitCode: code || 0 });
+      });
+      child.stderr.on("error", (error) => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        reject(error);
+      });
+    });
+  } catch {
+    console.error("Error while ecexuting the securedShell command");
+  }
+};
+var runTerminalCommand = async (input, projectCwd) => {
+  try {
+    if (input?.is_background) {
+      const child = spawn(input.command, {
+        cwd: projectCwd,
+        detached: true,
+        stdio: "ignore",
+        shell: true
+      });
+      child.unref();
+      console.log(`[LOCAL] Background command started: ${input.command}`);
+      return {
+        success: true,
+        message: `Background command started: ${input.command}`,
+        isBackground: true
+      };
+    } else {
+      const result = await runSecureTerminalCommand(
+        input.command,
+        3e4
+        // 30 second timeout
+      );
+      const success = result?.exitCode === 0;
+      return {
+        success,
+        stdout: result?.stdout?.trim(),
+        stderr: result?.stderr?.trim(),
+        exitCode: result?.exitCode,
+        message: success ? `Command executed successfully: ${input.command}` : `Command failed with exit code ${result?.exitCode}: ${input.command}`
+      };
+    }
+  } catch (error) {
+    console.error("Error while executing the terminal command", error);
+    return {
+      success: false,
+      message: "Error while executing the terminal command",
+      error: error.message
+    };
+  }
+};
 
 // src/server.ts
+var statusEmitter = new EventEmitter();
 var toolExecutors = {
   editFile: editFiles,
   deleteFile,
@@ -1360,7 +1489,8 @@ var toolExecutors = {
   glob: globTool,
   listDirectory: list,
   readFile: read_file,
-  stringReplace: apply_patch
+  stringReplace: apply_patch,
+  runTerminalCommand
 };
 function getConnectionStatus(ws) {
   return ws.readyState === WebSocket.CONNECTING ? "connecting" : ws.readyState === WebSocket.OPEN ? "open" : ws.readyState === WebSocket.CLOSING ? "closing" : "closed";
@@ -1378,6 +1508,7 @@ function connectToServer2(serverUrl = DEFAULT_SERVER_URL) {
   });
   ws.on("open", () => {
     console.log(pc2.green("Connected to server agent streams"));
+    statusEmitter.emit("status", { connected: true });
   });
   ws.on("message", async (data) => {
     const message = JSON.parse(data.toString());
@@ -1407,10 +1538,12 @@ function connectToServer2(serverUrl = DEFAULT_SERVER_URL) {
   });
   ws.on("close", () => {
     console.log(pc2.red("Disconnected from server. Reconnecting in 5s..."));
+    statusEmitter.emit("status", { connected: false });
     setTimeout(() => connectToServer2(serverUrl), 5e3);
   });
   ws.on("error", (error) => {
     console.error(pc2.red(`WebSocket error: ${error.message}`));
+    statusEmitter.emit("status", { connected: false });
   });
   return ws;
 }

package/dist/server.cjs

@@ -2,6 +2,7 @@
 'use strict';
 
 var WebSocket = require('ws');
+var events = require('events');
 var zod = require('zod');
 var promises = require('fs/promises');
 var path9 = require('path');
@@ -1256,10 +1257,50 @@ var startHttpServer = (connection) => {
   }
   const app = new hono.Hono();
   app.use(cors.cors());
-  app.post("/daemon/status/stream", (c) => {
+  app.post("/daemon/status", (c) => {
     const status = wsConnection ? getConnectionStatus(wsConnection) : "closed";
     return c.json({ connected: status === "open" });
   });
+  app.get("/daemon/status/stream", (c) => {
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+      start(controller) {
+        const initialStatus = wsConnection ? getConnectionStatus(wsConnection) : "closed";
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ connected: initialStatus === "open" })}
+
+`));
+        const statusHandler = (data) => {
+          try {
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
+
+`));
+          } catch {
+          }
+        };
+        statusEmitter.on("status", statusHandler);
+        const heartbeatInterval = setInterval(() => {
+          try {
+            const currentStatus = wsConnection ? getConnectionStatus(wsConnection) : "closed";
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify({ connected: currentStatus === "open" })}
+
+`));
+          } catch {
+          }
+        }, 15e3);
+        c.req.raw.signal.addEventListener("abort", () => {
+          statusEmitter.off("status", statusHandler);
+          clearInterval(heartbeatInterval);
+        });
+      }
+    });
+    return new Response(stream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive"
+      }
+    });
+  });
   app.get("context", async (c) => {
     const context = getContext(process.cwd());
     return c.body(JSON.stringify(context));
@@ -1361,8 +1402,96 @@ function getTokens() {
   const data = JSON.parse(raw);
   return data;
 }
+var ExplanationSchema = zod.z.object({
+  explanation: zod.z.string().describe("One sentence explanation as to why this tool is being used")
+});
+zod.z.object({
+  command: zod.z.string().describe("The terminal command to execute"),
+  is_background: zod.z.boolean().describe("Whether the command should be run in the background")
+}).merge(ExplanationSchema);
+var runSecureTerminalCommand = async (command, timeout) => {
+  try {
+    return new Promise((resolve, reject) => {
+      const child = child_process.spawn(command, {
+        cwd: process.cwd(),
+        stdio: ["pipe", "pipe", "pipe"],
+        shell: true
+      });
+      let stdout = "";
+      let stderr = "";
+      let timeoutId = null;
+      if (timeoutId > 0) {
+        timeoutId = setTimeout(() => {
+          child.kill("SIGKILL");
+          reject(new Error(`Command timed out after ${timeout}ms`));
+        }, timeout);
+      }
+      child.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+      child.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      child.stdout.on("close", (code) => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        resolve({ stdout, stderr, exitCode: code || 0 });
+      });
+      child.stderr.on("error", (error) => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        reject(error);
+      });
+    });
+  } catch {
+    console.error("Error while ecexuting the securedShell command");
+  }
+};
+var runTerminalCommand = async (input, projectCwd) => {
+  try {
+    if (input?.is_background) {
+      const child = child_process.spawn(input.command, {
+        cwd: projectCwd,
+        detached: true,
+        stdio: "ignore",
+        shell: true
+      });
+      child.unref();
+      console.log(`[LOCAL] Background command started: ${input.command}`);
+      return {
+        success: true,
+        message: `Background command started: ${input.command}`,
+        isBackground: true
+      };
+    } else {
+      const result = await runSecureTerminalCommand(
+        input.command,
+        3e4
+        // 30 second timeout
+      );
+      const success = result?.exitCode === 0;
+      return {
+        success,
+        stdout: result?.stdout?.trim(),
+        stderr: result?.stderr?.trim(),
+        exitCode: result?.exitCode,
+        message: success ? `Command executed successfully: ${input.command}` : `Command failed with exit code ${result?.exitCode}: ${input.command}`
+      };
+    }
+  } catch (error) {
+    console.error("Error while executing the terminal command", error);
+    return {
+      success: false,
+      message: "Error while executing the terminal command",
+      error: error.message
+    };
+  }
+};
 
 // src/server.ts
+var statusEmitter = new events.EventEmitter();
 var toolExecutors = {
   editFile: editFiles,
   deleteFile,
@@ -1370,7 +1499,8 @@ var toolExecutors = {
   glob: globTool,
   listDirectory: list,
   readFile: read_file,
-  stringReplace: apply_patch
+  stringReplace: apply_patch,
+  runTerminalCommand
 };
 function getConnectionStatus(ws) {
   return ws.readyState === WebSocket__default.default.CONNECTING ? "connecting" : ws.readyState === WebSocket__default.default.OPEN ? "open" : ws.readyState === WebSocket__default.default.CLOSING ? "closing" : "closed";
@@ -1388,6 +1518,7 @@ function connectToServer2(serverUrl = DEFAULT_SERVER_URL) {
   });
   ws.on("open", () => {
     console.log(pc2__default.default.green("Connected to server agent streams"));
+    statusEmitter.emit("status", { connected: true });
   });
   ws.on("message", async (data) => {
     const message = JSON.parse(data.toString());
@@ -1417,10 +1548,12 @@ function connectToServer2(serverUrl = DEFAULT_SERVER_URL) {
   });
   ws.on("close", () => {
     console.log(pc2__default.default.red("Disconnected from server. Reconnecting in 5s..."));
+    statusEmitter.emit("status", { connected: false });
     setTimeout(() => connectToServer2(serverUrl), 5e3);
   });
   ws.on("error", (error) => {
     console.error(pc2__default.default.red(`WebSocket error: ${error.message}`));
+    statusEmitter.emit("status", { connected: false });
   });
   return ws;
 }
@@ -1435,3 +1568,4 @@ async function main() {
 exports.connectToServer = connectToServer2;
 exports.getConnectionStatus = getConnectionStatus;
 exports.main = main;
+exports.statusEmitter = statusEmitter;

package/dist/server.d.cts

@@ -1,7 +1,9 @@
 import WebSocket from 'ws';
+import { EventEmitter } from 'events';
 
+declare const statusEmitter: EventEmitter<[never]>;
 declare function getConnectionStatus(ws: WebSocket): 'connecting' | 'open' | 'closing' | 'closed';
 declare function connectToServer(serverUrl?: string): WebSocket;
 declare function main(): Promise<void>;
 
-export { connectToServer, getConnectionStatus, main };
+export { connectToServer, getConnectionStatus, main, statusEmitter };

package/dist/server.d.ts

@@ -1,7 +1,9 @@
 import WebSocket from 'ws';
+import { EventEmitter } from 'events';
 
+declare const statusEmitter: EventEmitter<[never]>;
 declare function getConnectionStatus(ws: WebSocket): 'connecting' | 'open' | 'closing' | 'closed';
 declare function connectToServer(serverUrl?: string): WebSocket;
 declare function main(): Promise<void>;
 
-export { connectToServer, getConnectionStatus, main };
+export { connectToServer, getConnectionStatus, main, statusEmitter };

package/dist/server.js

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
 import WebSocket from 'ws';
+import { EventEmitter } from 'events';
 import { z } from 'zod';
 import { readFile, writeFile, stat, access, readdir, glob, unlink, mkdir } from 'fs/promises';
 import path9 from 'path';
 import fs3, { readdirSync } from 'fs';
 import os2 from 'os';
-import { exec } from 'child_process';
+import { exec, spawn } from 'child_process';
 import { promisify } from 'util';
 import pc2 from 'picocolors';
 import { Hono } from 'hono';
@@ -1246,10 +1247,50 @@ var startHttpServer = (connection) => {
   }
   const app = new Hono();
   app.use(cors());
-  app.post("/daemon/status/stream", (c) => {
+  app.post("/daemon/status", (c) => {
     const status = wsConnection ? getConnectionStatus(wsConnection) : "closed";
     return c.json({ connected: status === "open" });
   });
+  app.get("/daemon/status/stream", (c) => {
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+      start(controller) {
+        const initialStatus = wsConnection ? getConnectionStatus(wsConnection) : "closed";
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ connected: initialStatus === "open" })}
+
+`));
+        const statusHandler = (data) => {
+          try {
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
+
+`));
+          } catch {
+          }
+        };
+        statusEmitter.on("status", statusHandler);
+        const heartbeatInterval = setInterval(() => {
+          try {
+            const currentStatus = wsConnection ? getConnectionStatus(wsConnection) : "closed";
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify({ connected: currentStatus === "open" })}
+
+`));
+          } catch {
+          }
+        }, 15e3);
+        c.req.raw.signal.addEventListener("abort", () => {
+          statusEmitter.off("status", statusHandler);
+          clearInterval(heartbeatInterval);
+        });
+      }
+    });
+    return new Response(stream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive"
+      }
+    });
+  });
   app.get("context", async (c) => {
     const context = getContext(process.cwd());
     return c.body(JSON.stringify(context));
@@ -1351,8 +1392,96 @@ function getTokens() {
   const data = JSON.parse(raw);
   return data;
 }
+var ExplanationSchema = z.object({
+  explanation: z.string().describe("One sentence explanation as to why this tool is being used")
+});
+z.object({
+  command: z.string().describe("The terminal command to execute"),
+  is_background: z.boolean().describe("Whether the command should be run in the background")
+}).merge(ExplanationSchema);
+var runSecureTerminalCommand = async (command, timeout) => {
+  try {
+    return new Promise((resolve, reject) => {
+      const child = spawn(command, {
+        cwd: process.cwd(),
+        stdio: ["pipe", "pipe", "pipe"],
+        shell: true
+      });
+      let stdout = "";
+      let stderr = "";
+      let timeoutId = null;
+      if (timeoutId > 0) {
+        timeoutId = setTimeout(() => {
+          child.kill("SIGKILL");
+          reject(new Error(`Command timed out after ${timeout}ms`));
+        }, timeout);
+      }
+      child.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+      child.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      child.stdout.on("close", (code) => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        resolve({ stdout, stderr, exitCode: code || 0 });
+      });
+      child.stderr.on("error", (error) => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        reject(error);
+      });
+    });
+  } catch {
+    console.error("Error while ecexuting the securedShell command");
+  }
+};
+var runTerminalCommand = async (input, projectCwd) => {
+  try {
+    if (input?.is_background) {
+      const child = spawn(input.command, {
+        cwd: projectCwd,
+        detached: true,
+        stdio: "ignore",
+        shell: true
+      });
+      child.unref();
+      console.log(`[LOCAL] Background command started: ${input.command}`);
+      return {
+        success: true,
+        message: `Background command started: ${input.command}`,
+        isBackground: true
+      };
+    } else {
+      const result = await runSecureTerminalCommand(
+        input.command,
+        3e4
+        // 30 second timeout
+      );
+      const success = result?.exitCode === 0;
+      return {
+        success,
+        stdout: result?.stdout?.trim(),
+        stderr: result?.stderr?.trim(),
+        exitCode: result?.exitCode,
+        message: success ? `Command executed successfully: ${input.command}` : `Command failed with exit code ${result?.exitCode}: ${input.command}`
+      };
+    }
+  } catch (error) {
+    console.error("Error while executing the terminal command", error);
+    return {
+      success: false,
+      message: "Error while executing the terminal command",
+      error: error.message
+    };
+  }
+};
 
 // src/server.ts
+var statusEmitter = new EventEmitter();
 var toolExecutors = {
   editFile: editFiles,
   deleteFile,
@@ -1360,7 +1489,8 @@ var toolExecutors = {
   glob: globTool,
   listDirectory: list,
   readFile: read_file,
-  stringReplace: apply_patch
+  stringReplace: apply_patch,
+  runTerminalCommand
 };
 function getConnectionStatus(ws) {
   return ws.readyState === WebSocket.CONNECTING ? "connecting" : ws.readyState === WebSocket.OPEN ? "open" : ws.readyState === WebSocket.CLOSING ? "closing" : "closed";
@@ -1378,6 +1508,7 @@ function connectToServer2(serverUrl = DEFAULT_SERVER_URL) {
   });
   ws.on("open", () => {
     console.log(pc2.green("Connected to server agent streams"));
+    statusEmitter.emit("status", { connected: true });
   });
   ws.on("message", async (data) => {
     const message = JSON.parse(data.toString());
@@ -1407,10 +1538,12 @@ function connectToServer2(serverUrl = DEFAULT_SERVER_URL) {
   });
   ws.on("close", () => {
     console.log(pc2.red("Disconnected from server. Reconnecting in 5s..."));
+    statusEmitter.emit("status", { connected: false });
     setTimeout(() => connectToServer2(serverUrl), 5e3);
   });
   ws.on("error", (error) => {
     console.error(pc2.red(`WebSocket error: ${error.message}`));
+    statusEmitter.emit("status", { connected: false });
   });
   return ws;
 }
@@ -1422,4 +1555,4 @@ async function main() {
   startHttpServer(connection);
 }
 
-export { connectToServer2 as connectToServer, getConnectionStatus, main };
+export { connectToServer2 as connectToServer, getConnectionStatus, main, statusEmitter };

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "amai",
     "type": "module",
-    "version": "0.0.2",
+    "version": "0.0.4",
     "description": "ama rpc daemon",
     "keywords": [
         "ama",