amai 0.0.3 → 0.0.4

package/dist/cli.cjs

@@ -1547,6 +1547,93 @@ 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();
@@ -1557,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";
@@ -1807,7 +1895,7 @@ function getDaemonPid() {
     return null;
   }
 }
-var VERSION = "0.0.3";
+var VERSION = "0.0.4";
 var PROJECT_DIR = process.cwd();
 function promptUser(question) {
   const rl = readline__default.default.createInterface({

package/dist/cli.js

@@ -1535,6 +1535,93 @@ 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();
@@ -1545,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";
@@ -1795,7 +1883,7 @@ function getDaemonPid() {
     return null;
   }
 }
-var VERSION = "0.0.3";
+var VERSION = "0.0.4";
 var PROJECT_DIR = process.cwd();
 function promptUser(question) {
   const rl = readline.createInterface({

package/dist/lib/daemon-entry.cjs

@@ -1402,6 +1402,93 @@ 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();
@@ -1412,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";

package/dist/lib/daemon-entry.js

@@ -1392,6 +1392,93 @@ 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();
@@ -1402,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";

package/dist/server.cjs

@@ -1402,6 +1402,93 @@ 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();
@@ -1412,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";

package/dist/server.js

@@ -6,7 +6,7 @@ import { readFile, writeFile, stat, access, readdir, glob, unlink, mkdir } from
 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';
@@ -1392,6 +1392,93 @@ 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();
@@ -1402,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";

package/package.json

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