amai 0.0.1

package/dist/server.cjs

@@ -0,0 +1,1437 @@
+#!/usr/bin/env node
+'use strict';
+
+var WebSocket = require('ws');
+var zod = require('zod');
+var promises = require('fs/promises');
+var path9 = require('path');
+var fs3 = require('fs');
+var os2 = require('os');
+var child_process = require('child_process');
+var util = require('util');
+var pc2 = require('picocolors');
+var hono = require('hono');
+var nodeServer = require('@hono/node-server');
+var cors = require('hono/cors');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var WebSocket__default = /*#__PURE__*/_interopDefault(WebSocket);
+var path9__default = /*#__PURE__*/_interopDefault(path9);
+var fs3__default = /*#__PURE__*/_interopDefault(fs3);
+var os2__default = /*#__PURE__*/_interopDefault(os2);
+var pc2__default = /*#__PURE__*/_interopDefault(pc2);
+
+var DEFAULT_SERVER_URL = "wss://ama-production-a628.up.railway.app";
+var AMA_DIR = path9__default.default.join(os2__default.default.homedir(), ".ama");
+path9__default.default.join(AMA_DIR, "code");
+path9__default.default.join(AMA_DIR, "storage");
+
+// src/lib/project-registry.ts
+var REGISTRY_FILE = path9__default.default.join(AMA_DIR, "projects.json");
+var ProjectRegistry = class {
+  projects = /* @__PURE__ */ new Map();
+  constructor() {
+    this.load();
+  }
+  load() {
+    try {
+      if (fs3__default.default.existsSync(REGISTRY_FILE)) {
+        const data = fs3__default.default.readFileSync(REGISTRY_FILE, "utf8");
+        const parsed = JSON.parse(data);
+        if (!Array.isArray(parsed)) {
+          console.error("Invalid project registry format: expected array, got", typeof parsed);
+          const backupFile = REGISTRY_FILE + ".backup." + Date.now();
+          fs3__default.default.copyFileSync(REGISTRY_FILE, backupFile);
+          fs3__default.default.unlinkSync(REGISTRY_FILE);
+          return;
+        }
+        const projects = parsed;
+        this.projects.clear();
+        projects.forEach((project) => {
+          if (project && typeof project === "object" && project.id && project.cwd) {
+            this.projects.set(project.id, project);
+          }
+        });
+      }
+    } catch (error) {
+      console.error("Failed to load project registry:", error);
+      if (fs3__default.default.existsSync(REGISTRY_FILE)) {
+        try {
+          const backupFile = REGISTRY_FILE + ".backup." + Date.now();
+          fs3__default.default.copyFileSync(REGISTRY_FILE, backupFile);
+          fs3__default.default.unlinkSync(REGISTRY_FILE);
+          console.log("Corrupted registry file backed up and removed. Starting fresh.");
+        } catch (backupError) {
+        }
+      }
+    }
+  }
+  save() {
+    try {
+      if (!fs3__default.default.existsSync(AMA_DIR)) {
+        fs3__default.default.mkdirSync(AMA_DIR, { recursive: true });
+      }
+      const projects = Array.from(this.projects.values());
+      fs3__default.default.writeFileSync(REGISTRY_FILE, JSON.stringify(projects, null, 2), "utf8");
+    } catch (error) {
+      console.error("Failed to save project registry:", error);
+    }
+  }
+  register(projectId, cwd, name) {
+    const normalizedCwd = path9__default.default.normalize(path9__default.default.resolve(cwd));
+    this.projects.set(projectId, {
+      id: projectId,
+      cwd: normalizedCwd,
+      name: name || path9__default.default.basename(normalizedCwd),
+      active: true
+    });
+    this.save();
+  }
+  unregister(projectId) {
+    this.projects.delete(projectId);
+    this.save();
+  }
+  getProjectCwd(projectId) {
+    const project = this.projects.get(projectId);
+    return project?.cwd || null;
+  }
+  isPathAllowed(projectId, targetPath) {
+    const projectCwd = this.getProjectCwd(projectId);
+    if (!projectCwd) {
+      return false;
+    }
+    return isPathWithinProject(targetPath, projectCwd);
+  }
+  list() {
+    return Array.from(this.projects.values());
+  }
+  getProject(projectId) {
+    return this.projects.get(projectId) || null;
+  }
+};
+var projectRegistry = new ProjectRegistry();
+function isPathWithinProject(filePath, projectCwd) {
+  try {
+    const resolved = path9__default.default.resolve(projectCwd, filePath);
+    const normalized = path9__default.default.normalize(resolved);
+    const normalizedCwd = path9__default.default.normalize(projectCwd);
+    return normalized.startsWith(normalizedCwd);
+  } catch {
+    return false;
+  }
+}
+
+// src/lib/sandbox.ts
+function validatePath(filePath, projectCwd) {
+  if (!projectCwd) {
+    return {
+      valid: false,
+      error: "ACCESS_DENIED: No project context provided"
+    };
+  }
+  try {
+    const resolvedPath = path9__default.default.resolve(projectCwd, filePath);
+    if (!isPathWithinProject(filePath, projectCwd)) {
+      return {
+        valid: false,
+        error: `ACCESS_DENIED: Path "${filePath}" is outside project directory "${projectCwd}"`
+      };
+    }
+    return {
+      valid: true,
+      resolvedPath
+    };
+  } catch (error) {
+    return {
+      valid: false,
+      error: `ACCESS_DENIED: Invalid path "${filePath}"`
+    };
+  }
+}
+function resolveProjectPath(filePath, projectCwd) {
+  return path9__default.default.resolve(projectCwd, filePath);
+}
+
+// src/tools/read-file.ts
+zod.z.object({
+  relative_file_path: zod.z.string().describe("The relative path to the file to read."),
+  should_read_entire_file: zod.z.boolean().describe("Whether to read the entire file."),
+  start_line_one_indexed: zod.z.number().optional().describe(
+    "The one-indexed line number to start reading from (inclusive)."
+  ),
+  end_line_one_indexed: zod.z.number().optional().describe("The one-indexed line number to end reading at (inclusive).")
+});
+var read_file = async function(input, projectCwd) {
+  const { relative_file_path, should_read_entire_file, start_line_one_indexed, end_line_one_indexed } = input;
+  try {
+    if (!relative_file_path) {
+      return {
+        success: false,
+        message: "Missing required parameter: target_file",
+        error: "MISSING_TARGET_FILE"
+      };
+    }
+    if (!should_read_entire_file) {
+      if (start_line_one_indexed === void 0 || end_line_one_indexed === void 0) {
+        return {
+          success: false,
+          message: "start_line_one_indexed and end_line_one_indexed are required when should_read_entire_file is false",
+          error: "MISSING_LINE_RANGE"
+        };
+      }
+      if (!Number.isInteger(start_line_one_indexed) || start_line_one_indexed < 1) {
+        return {
+          success: false,
+          message: "start_line_one_indexed must be a positive integer (1-indexed)",
+          error: "INVALID_START_LINE"
+        };
+      }
+      if (!Number.isInteger(end_line_one_indexed) || end_line_one_indexed < 1) {
+        return {
+          success: false,
+          message: "end_line_one_indexed must be a positive integer (1-indexed)",
+          error: "INVALID_END_LINE"
+        };
+      }
+      if (end_line_one_indexed < start_line_one_indexed) {
+        return {
+          success: false,
+          message: "end_line_one_indexed must be greater than or equal to start_line_one_indexed",
+          error: "INVALID_LINE_RANGE"
+        };
+      }
+    }
+    if (projectCwd) {
+      const validation = validatePath(relative_file_path, projectCwd);
+      if (!validation.valid) {
+        return {
+          success: false,
+          message: validation.error || "Path validation failed",
+          error: "ACCESS_DENIED"
+        };
+      }
+      const absolute_file_path = validation.resolvedPath;
+      try {
+        const fileStats = await promises.stat(absolute_file_path);
+        if (!fileStats.isFile()) {
+          return {
+            success: false,
+            message: `Path is not a file: ${relative_file_path}`,
+            error: "NOT_A_FILE"
+          };
+        }
+      } catch (error) {
+        if (error?.code === "ENOENT") {
+          return {
+            success: false,
+            message: `File not found: ${relative_file_path}`,
+            error: "FILE_NOT_FOUND"
+          };
+        }
+        return {
+          success: false,
+          message: `Failed to access file: ${relative_file_path}`,
+          error: "READ_ERROR"
+        };
+      }
+      try {
+        const fileContent = await promises.readFile(absolute_file_path, "utf-8");
+        const lines = fileContent.split(/\r?\n/);
+        const totalLines = lines.length;
+        if (should_read_entire_file) {
+          return {
+            success: true,
+            message: `Successfully read entire file: ${relative_file_path} (${totalLines} lines)`,
+            content: fileContent,
+            totalLines
+          };
+        }
+        const startIndex = start_line_one_indexed - 1;
+        if (startIndex >= totalLines) {
+          return {
+            success: false,
+            message: "start_line_one_indexed must be less than or equal to the total number of lines in the file",
+            error: "INVALID_LINE_RANGE"
+          };
+        }
+        const normalizedEnd = Math.min(end_line_one_indexed, totalLines);
+        const selectedLines = lines.slice(startIndex, normalizedEnd).join("\n");
+        const linesRead = normalizedEnd - start_line_one_indexed + 1;
+        return {
+          success: true,
+          message: `Successfully read lines ${start_line_one_indexed}-${normalizedEnd} from file: ${relative_file_path} (${linesRead} lines of ${totalLines} total)`,
+          content: selectedLines,
+          totalLines
+        };
+      } catch {
+        return {
+          success: false,
+          message: `Failed to read file: ${relative_file_path}`,
+          error: "READ_ERROR"
+        };
+      }
+    } else {
+      const absolute_file_path = path9__default.default.resolve(relative_file_path);
+      try {
+        const fileStats = await promises.stat(absolute_file_path);
+        if (!fileStats.isFile()) {
+          return {
+            success: false,
+            message: `Path is not a file: ${relative_file_path}`,
+            error: "NOT_A_FILE"
+          };
+        }
+      } catch (error) {
+        if (error?.code === "ENOENT") {
+          return {
+            success: false,
+            message: `File not found: ${relative_file_path}`,
+            error: "FILE_NOT_FOUND"
+          };
+        }
+        return {
+          success: false,
+          message: `Failed to access file: ${relative_file_path}`,
+          error: "READ_ERROR"
+        };
+      }
+      try {
+        const fileContent = await promises.readFile(absolute_file_path, "utf-8");
+        const lines = fileContent.split(/\r?\n/);
+        const totalLines = lines.length;
+        if (should_read_entire_file) {
+          return {
+            success: true,
+            message: `Successfully read entire file: ${relative_file_path} (${totalLines} lines)`,
+            content: fileContent,
+            totalLines
+          };
+        }
+        const startIndex = start_line_one_indexed - 1;
+        if (startIndex >= totalLines) {
+          return {
+            success: false,
+            message: "start_line_one_indexed must be less than or equal to the total number of lines in the file",
+            error: "INVALID_LINE_RANGE"
+          };
+        }
+        const normalizedEnd = Math.min(end_line_one_indexed, totalLines);
+        const selectedLines = lines.slice(startIndex, normalizedEnd).join("\n");
+        const linesRead = normalizedEnd - start_line_one_indexed + 1;
+        return {
+          success: true,
+          message: `Successfully read lines ${start_line_one_indexed}-${normalizedEnd} from file: ${relative_file_path} (${linesRead} lines of ${totalLines} total)`,
+          content: selectedLines,
+          totalLines
+        };
+      } catch {
+        return {
+          success: false,
+          message: `Failed to read file: ${relative_file_path}`,
+          error: "READ_ERROR"
+        };
+      }
+    }
+  } catch {
+    return {
+      success: false,
+      message: `Failed to read file: ${relative_file_path}`,
+      error: "READ_ERROR"
+    };
+  }
+};
+
+// ../../node_modules/.bun/diff@8.0.2/node_modules/diff/libesm/diff/base.js
+var Diff = class {
+  diff(oldStr, newStr, options = {}) {
+    let callback;
+    if (typeof options === "function") {
+      callback = options;
+      options = {};
+    } else if ("callback" in options) {
+      callback = options.callback;
+    }
+    const oldString = this.castInput(oldStr, options);
+    const newString = this.castInput(newStr, options);
+    const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
+    const newTokens = this.removeEmpty(this.tokenize(newString, options));
+    return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
+  }
+  diffWithOptionsObj(oldTokens, newTokens, options, callback) {
+    var _a;
+    const done = (value) => {
+      value = this.postProcess(value, options);
+      if (callback) {
+        setTimeout(function() {
+          callback(value);
+        }, 0);
+        return void 0;
+      } else {
+        return value;
+      }
+    };
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let editLength = 1;
+    let maxEditLength = newLen + oldLen;
+    if (options.maxEditLength != null) {
+      maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+    }
+    const maxExecutionTime = (_a = options.timeout) !== null && _a !== void 0 ? _a : Infinity;
+    const abortAfterTimestamp = Date.now() + maxExecutionTime;
+    const bestPath = [{ oldPos: -1, lastComponent: void 0 }];
+    let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
+    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+      return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
+    }
+    let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
+    const execEditLength = () => {
+      for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+        let basePath;
+        const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
+        if (removePath) {
+          bestPath[diagonalPath - 1] = void 0;
+        }
+        let canAdd = false;
+        if (addPath) {
+          const addPathNewPos = addPath.oldPos - diagonalPath;
+          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+        }
+        const canRemove = removePath && removePath.oldPos + 1 < oldLen;
+        if (!canAdd && !canRemove) {
+          bestPath[diagonalPath] = void 0;
+          continue;
+        }
+        if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
+          basePath = this.addToPath(addPath, true, false, 0, options);
+        } else {
+          basePath = this.addToPath(removePath, false, true, 1, options);
+        }
+        newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
+        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+          return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
+        } else {
+          bestPath[diagonalPath] = basePath;
+          if (basePath.oldPos + 1 >= oldLen) {
+            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+          }
+          if (newPos + 1 >= newLen) {
+            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+          }
+        }
+      }
+      editLength++;
+    };
+    if (callback) {
+      (function exec2() {
+        setTimeout(function() {
+          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
+            return callback(void 0);
+          }
+          if (!execEditLength()) {
+            exec2();
+          }
+        }, 0);
+      })();
+    } else {
+      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
+        const ret = execEditLength();
+        if (ret) {
+          return ret;
+        }
+      }
+    }
+  }
+  addToPath(path12, added, removed, oldPosInc, options) {
+    const last = path12.lastComponent;
+    if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
+      return {
+        oldPos: path12.oldPos + oldPosInc,
+        lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
+      };
+    } else {
+      return {
+        oldPos: path12.oldPos + oldPosInc,
+        lastComponent: { count: 1, added, removed, previousComponent: last }
+      };
+    }
+  }
+  extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
+      newPos++;
+      oldPos++;
+      commonCount++;
+      if (options.oneChangePerToken) {
+        basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
+      }
+    }
+    if (commonCount && !options.oneChangePerToken) {
+      basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
+    }
+    basePath.oldPos = oldPos;
+    return newPos;
+  }
+  equals(left, right, options) {
+    if (options.comparator) {
+      return options.comparator(left, right);
+    } else {
+      return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
+    }
+  }
+  removeEmpty(array) {
+    const ret = [];
+    for (let i = 0; i < array.length; i++) {
+      if (array[i]) {
+        ret.push(array[i]);
+      }
+    }
+    return ret;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  castInput(value, options) {
+    return value;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  tokenize(value, options) {
+    return Array.from(value);
+  }
+  join(chars) {
+    return chars.join("");
+  }
+  postProcess(changeObjects, options) {
+    return changeObjects;
+  }
+  get useLongestToken() {
+    return false;
+  }
+  buildValues(lastComponent, newTokens, oldTokens) {
+    const components = [];
+    let nextComponent;
+    while (lastComponent) {
+      components.push(lastComponent);
+      nextComponent = lastComponent.previousComponent;
+      delete lastComponent.previousComponent;
+      lastComponent = nextComponent;
+    }
+    components.reverse();
+    const componentLen = components.length;
+    let componentPos = 0, newPos = 0, oldPos = 0;
+    for (; componentPos < componentLen; componentPos++) {
+      const component = components[componentPos];
+      if (!component.removed) {
+        if (!component.added && this.useLongestToken) {
+          let value = newTokens.slice(newPos, newPos + component.count);
+          value = value.map(function(value2, i) {
+            const oldValue = oldTokens[oldPos + i];
+            return oldValue.length > value2.length ? oldValue : value2;
+          });
+          component.value = this.join(value);
+        } else {
+          component.value = this.join(newTokens.slice(newPos, newPos + component.count));
+        }
+        newPos += component.count;
+        if (!component.added) {
+          oldPos += component.count;
+        }
+      } else {
+        component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
+        oldPos += component.count;
+      }
+    }
+    return components;
+  }
+};
+
+// ../../node_modules/.bun/diff@8.0.2/node_modules/diff/libesm/diff/line.js
+var LineDiff = class extends Diff {
+  constructor() {
+    super(...arguments);
+    this.tokenize = tokenize;
+  }
+  equals(left, right, options) {
+    if (options.ignoreWhitespace) {
+      if (!options.newlineIsToken || !left.includes("\n")) {
+        left = left.trim();
+      }
+      if (!options.newlineIsToken || !right.includes("\n")) {
+        right = right.trim();
+      }
+    } else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
+      if (left.endsWith("\n")) {
+        left = left.slice(0, -1);
+      }
+      if (right.endsWith("\n")) {
+        right = right.slice(0, -1);
+      }
+    }
+    return super.equals(left, right, options);
+  }
+};
+var lineDiff = new LineDiff();
+function diffLines(oldStr, newStr, options) {
+  return lineDiff.diff(oldStr, newStr, options);
+}
+function tokenize(value, options) {
+  if (options.stripTrailingCr) {
+    value = value.replace(/\r\n/g, "\n");
+  }
+  const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
+  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+    linesAndNewlines.pop();
+  }
+  for (let i = 0; i < linesAndNewlines.length; i++) {
+    const line = linesAndNewlines[i];
+    if (i % 2 && !options.newlineIsToken) {
+      retLines[retLines.length - 1] += line;
+    } else {
+      retLines.push(line);
+    }
+  }
+  return retLines;
+}
+
+// src/lib/diff.ts
+function calculateDiffStats(oldContent, newContent) {
+  const changes = diffLines(oldContent, newContent);
+  let linesAdded = 0;
+  let linesRemoved = 0;
+  for (const change of changes) {
+    if (change.added) {
+      linesAdded += change.count || 0;
+    } else if (change.removed) {
+      linesRemoved += change.count || 0;
+    }
+  }
+  return { linesAdded, linesRemoved };
+}
+
+// src/tools/apply-patch.ts
+zod.z.object({
+  file_path: zod.z.string().describe("The path to the file you want to search and replace in. You can use either a relative path in the workspace or an absolute path. If an absolute path is provided, it will be preserved as is"),
+  new_string: zod.z.string().describe("The edited text to replace the old_string (must be different from the old_string)"),
+  old_string: zod.z.string().describe("The text to replace (must be unique within the file, and must match the file contents exactly, including all whitespace and indentation)")
+});
+var apply_patch = async function(input, projectCwd) {
+  const { file_path, new_string, old_string } = input;
+  try {
+    if (!file_path) {
+      return {
+        success: false,
+        message: "Missing required parameter: file_path",
+        error: "MISSING_FILE_PATH"
+      };
+    }
+    if (old_string === void 0 || old_string === null) {
+      return {
+        success: false,
+        message: "Missing required parameter: old_string",
+        error: "MISSING_OLD_STRING"
+      };
+    }
+    if (new_string === void 0 || new_string === null) {
+      return {
+        success: false,
+        message: "Missing required parameter: new_string",
+        error: "MISSING_NEW_STRING"
+      };
+    }
+    if (old_string === new_string) {
+      return {
+        success: false,
+        message: "old_string and new_string must be different",
+        error: "STRINGS_IDENTICAL"
+      };
+    }
+    if (projectCwd) {
+      const validation = validatePath(file_path, projectCwd);
+      if (!validation.valid) {
+        return {
+          success: false,
+          message: validation.error || "Path validation failed",
+          error: "ACCESS_DENIED"
+        };
+      }
+    }
+    const basePath = projectCwd || process.cwd();
+    const absolute_file_path = resolveProjectPath(file_path, basePath);
+    let fileContent;
+    try {
+      fileContent = await promises.readFile(absolute_file_path, "utf-8");
+    } catch (error) {
+      if (error?.code === "ENOENT") {
+        return {
+          success: false,
+          message: `File not found: ${file_path}`,
+          error: "FILE_NOT_FOUND"
+        };
+      }
+      return {
+        success: false,
+        message: `Failed to read file: ${file_path}`,
+        error: "READ_ERROR"
+      };
+    }
+    if (!fileContent.includes(old_string)) {
+      return {
+        success: false,
+        message: `old_string not found in file: ${file_path}`,
+        error: "STRING_NOT_FOUND"
+      };
+    }
+    const occurrences = fileContent.split(old_string).length - 1;
+    if (occurrences > 1) {
+      return {
+        success: false,
+        message: `old_string appears ${occurrences} times in the file. It must be unique. Please include more context to make it unique.`,
+        error: "STRING_NOT_UNIQUE"
+      };
+    }
+    const newContent = fileContent.replace(old_string, new_string);
+    try {
+      await promises.writeFile(absolute_file_path, newContent, "utf-8");
+      const diffStats = calculateDiffStats(fileContent, newContent);
+      return {
+        success: true,
+        old_string,
+        new_string,
+        linesAdded: diffStats.linesAdded,
+        linesRemoved: diffStats.linesRemoved,
+        message: `Successfully replaced string in file: ${file_path}`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Failed to write to file: ${file_path}`,
+        error: "WRITE_ERROR"
+      };
+    }
+  } catch (error) {
+    return {
+      success: false,
+      message: `Unexpected error: ${error.message}`,
+      error: "UNEXPECTED_ERROR"
+    };
+  }
+};
+zod.z.object({
+  target_file: zod.z.string().describe("The relative path to the file to modify. The tool will create any directories in the path that don't exist"),
+  content: zod.z.string().describe("The content to write to the file"),
+  providedNewFile: zod.z.boolean().describe("The new file content to write to the file").optional()
+});
+var editFiles = async function(input, projectCwd) {
+  const { target_file, content, providedNewFile } = input;
+  try {
+    if (projectCwd) {
+      const validation = validatePath(target_file, projectCwd);
+      if (!validation.valid) {
+        return {
+          success: false,
+          error: validation.error || "Path validation failed",
+          message: `Failed to edit file: ${target_file}`
+        };
+      }
+    }
+    const basePath = projectCwd || process.cwd();
+    const filePath = resolveProjectPath(target_file, basePath);
+    const dirPath = path9__default.default.dirname(filePath);
+    await promises.mkdir(dirPath, { recursive: true });
+    let isNewFile = providedNewFile;
+    let existingContent = "";
+    if (isNewFile === void 0) {
+      try {
+        existingContent = await fs3__default.default.promises.readFile(filePath, "utf-8");
+        isNewFile = false;
+      } catch (error) {
+        isNewFile = true;
+      }
+    } else if (!isNewFile) {
+      try {
+        existingContent = await fs3__default.default.promises.readFile(filePath, "utf-8");
+      } catch (error) {
+        isNewFile = true;
+      }
+    }
+    await fs3__default.default.promises.writeFile(filePath, content);
+    const diffStats = calculateDiffStats(existingContent, content);
+    if (isNewFile) {
+      return {
+        success: true,
+        isNewFile: true,
+        old_string: "",
+        new_string: content,
+        message: `Created new file: ${target_file}`,
+        linesAdded: diffStats.linesAdded,
+        linesRemoved: diffStats.linesRemoved
+      };
+    } else {
+      return {
+        success: true,
+        isNewFile: false,
+        old_string: existingContent,
+        new_string: content,
+        message: `Modified file: ${target_file}`,
+        linesAdded: diffStats.linesAdded,
+        linesRemoved: diffStats.linesRemoved
+      };
+    }
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error",
+      message: `Failed to edit file: ${target_file}`
+    };
+  }
+};
+zod.z.object({
+  path: zod.z.string().describe("Relative file path to delete")
+});
+var deleteFile = async function(input, projectCwd) {
+  const { path: realPath } = input;
+  if (!realPath) {
+    return {
+      success: false,
+      message: "Missing required parameter: path",
+      error: "MISSING_PATH"
+    };
+  }
+  if (projectCwd) {
+    const validation = validatePath(realPath, projectCwd);
+    if (!validation.valid) {
+      return {
+        success: false,
+        message: validation.error || "Path validation failed",
+        error: "ACCESS_DENIED"
+      };
+    }
+  }
+  try {
+    const basePath = projectCwd || process.cwd();
+    const absolute_file_path = resolveProjectPath(realPath, basePath);
+    if (!absolute_file_path) {
+      return {
+        success: false,
+        message: "Invalid file path",
+        error: "INVALID_FILE_PATH"
+      };
+    }
+    const originalContent = await promises.readFile(absolute_file_path);
+    if (originalContent === void 0) {
+      return {
+        success: false,
+        message: `Failed to read file before deletion: ${realPath}`,
+        error: "READ_ERROR"
+      };
+    }
+    const deleteResult = await promises.unlink(absolute_file_path).catch(() => {
+      return {
+        success: false,
+        message: `Failed to read file before deletion: ${realPath}`,
+        error: "DELETE_ERROR"
+      };
+    });
+    if (!deleteResult?.success) {
+      return {
+        success: false,
+        message: `Failed to delete file before deletion: ${realPath}`,
+        error: "DELETE_ERROR"
+      };
+    }
+    return {
+      success: true,
+      message: `Successfully deleted file: ${realPath}`,
+      content: originalContent
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed to delete file: ${realPath}`,
+      error: "DELETE_ERROR"
+    };
+  }
+};
+zod.z.object({
+  query: zod.z.string().describe("The regex pattern to search for"),
+  options: zod.z.object({
+    includePattern: zod.z.string().optional().describe('Glob pattern for files to include (e.g., "*.ts")'),
+    excludePattern: zod.z.string().optional().describe("Glob pattern for files to exclude"),
+    caseSensitive: zod.z.boolean().optional().describe("Whether the search should be case sensitive")
+  })
+});
+var execAsync = util.promisify(child_process.exec);
+var grepTool = async function(input, projectCwd) {
+  const { query, options } = input;
+  try {
+    const { includePattern, excludePattern: excludePattern2, caseSensitive } = options || {};
+    const searchDir = projectCwd || process.cwd();
+    if (projectCwd && !path9__default.default.isAbsolute(projectCwd)) {
+      return {
+        success: false,
+        message: "Invalid project directory",
+        error: "INVALID_PROJECT_DIR"
+      };
+    }
+    let command = `rg -n --with-filename "${query}"`;
+    if (caseSensitive) {
+      command += " -i";
+    }
+    if (includePattern) {
+      command += ` --glob "${includePattern}"`;
+    }
+    if (excludePattern2) {
+      command += ` --glob "!${excludePattern2}"`;
+    }
+    command += ` --max-count 50`;
+    command += ` "${searchDir}"`;
+    const { stdout } = await execAsync(command);
+    const rawMatches = stdout.trim().split("\n").filter((line) => line.length > 0);
+    const detailedMatches = [];
+    const matches = [];
+    for (const rawMatch of rawMatches) {
+      const colonIndex = rawMatch.indexOf(":");
+      const secondColonIndex = rawMatch.indexOf(":", colonIndex + 1);
+      if (colonIndex > 0 && secondColonIndex > colonIndex) {
+        const file = rawMatch.substring(0, colonIndex);
+        const lineNumber = parseInt(rawMatch.substring(colonIndex + 1, secondColonIndex), 10);
+        let content = rawMatch.substring(secondColonIndex + 1);
+        if (content.length > 250) {
+          content = content.substring(0, 250) + "...";
+        }
+        detailedMatches.push({
+          file,
+          lineNumber,
+          content
+        });
+        matches.push(`${file}:${lineNumber}:${content}`);
+      } else {
+        matches.push(rawMatch);
+      }
+    }
+    return {
+      success: true,
+      matches,
+      detailedMatches,
+      query,
+      matchCount: matches.length,
+      message: `Found ${matches.length} matches for pattern: ${query}`
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: error?.message || String(error),
+      error: "GREP_EXEC_ERROR"
+    };
+  }
+};
+zod.z.object({
+  pattern: zod.z.string().describe('Glob pattern (e.g., "**/*.js")'),
+  path: zod.z.string().optional().describe("Relative directory path to search in")
+});
+var globTool = async function(input, projectCwd) {
+  const { pattern, path: inputPath } = input;
+  if (!pattern) {
+    return {
+      success: false,
+      message: "Missing required parameter: pattern",
+      error: "MISSING_PATTERN"
+    };
+  }
+  try {
+    const basePath = projectCwd || process.cwd();
+    const searchPath = inputPath ? resolveProjectPath(inputPath, basePath) : basePath;
+    if (projectCwd && inputPath) {
+      const validation = validatePath(inputPath, projectCwd);
+      if (!validation.valid) {
+        return {
+          success: false,
+          message: validation.error || "Path validation failed",
+          error: "ACCESS_DENIED"
+        };
+      }
+    }
+    const filesGenerator = promises.glob(pattern, {
+      cwd: searchPath
+    });
+    const files = [];
+    for await (const file of filesGenerator) {
+      files.push(file);
+    }
+    const searchLocation = inputPath ? ` in "${inputPath}"` : " in current directory";
+    const message = `Found ${files.length} matches for pattern "${pattern}"${searchLocation}`;
+    return {
+      success: true,
+      message,
+      content: files
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed to find files matching pattern: ${pattern}`,
+      error: "GLOB_ERROR"
+    };
+  }
+};
+var excludePatterns = [
+  "node_modules",
+  "dist",
+  "build",
+  "coverage",
+  "logs",
+  "tmp"
+];
+var excludePattern = excludePatterns.join("|");
+zod.z.object({
+  path: zod.z.string().optional(),
+  recursive: zod.z.boolean().optional().describe("Whether to list files recursively"),
+  maxDepth: zod.z.number().optional().describe("Maximum recursion depth (default: unlimited)"),
+  pattern: zod.z.string().optional().describe("File extension (e.g., '.ts') or glob-like pattern"),
+  includeDirectories: zod.z.boolean().optional().describe("Whether to include directories in results (default: true)"),
+  includeFiles: zod.z.boolean().optional().describe("Whether to include files in results (default: true)")
+});
+var list = async function(input, projectCwd) {
+  const { path: relativePath, recursive, maxDepth, pattern, includeDirectories, includeFiles } = input;
+  if (maxDepth !== void 0) {
+    if (!Number.isInteger(maxDepth) || maxDepth < 0) {
+      return {
+        success: false,
+        message: "maxDepth must be a non-negative integer",
+        error: "INVALID_MAX_DEPTH"
+      };
+    }
+  }
+  const includeFilesNormalized = includeFiles ?? true;
+  const includeDirectoriesNormalized = includeDirectories ?? true;
+  if (!includeFilesNormalized && !includeDirectoriesNormalized) {
+    return {
+      success: false,
+      message: "At least one of includeFiles or includeDirectories must be true",
+      error: "INVALID_INCLUDE_OPTIONS"
+    };
+  }
+  try {
+    const basePath = projectCwd || process.cwd();
+    const absolutePath = relativePath ? resolveProjectPath(relativePath, basePath) : basePath;
+    if (projectCwd && relativePath) {
+      const validation = validatePath(relativePath, projectCwd);
+      if (!validation.valid) {
+        return {
+          success: false,
+          message: validation.error || "Path validation failed",
+          error: "ACCESS_DENIED"
+        };
+      }
+    }
+    try {
+      await promises.access(absolutePath);
+    } catch {
+      return {
+        success: false,
+        message: `File does not exist: ${absolutePath}`,
+        error: "FILE_DOES_NOT_EXIST"
+      };
+    }
+    const isDir = (await promises.stat(absolutePath)).isDirectory();
+    if (!isDir) {
+      return {
+        success: false,
+        message: `File is not a directory: ${absolutePath}`,
+        error: "FILE_IS_NOT_A_DIRECTORY"
+      };
+    }
+    const collected = [];
+    const patternMatcher = (() => {
+      if (!pattern) return null;
+      if (pattern.startsWith(".") && !pattern.includes("*") && !pattern.includes("?")) {
+        return (entryName) => entryName.endsWith(pattern);
+      }
+      const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+      const regex = new RegExp(`^${escaped}$`);
+      return (entryName) => regex.test(entryName);
+    })();
+    const matchPattern = (entryName) => {
+      if (!patternMatcher) return true;
+      return patternMatcher(entryName);
+    };
+    const maxDepthNormalized = recursive ? maxDepth ?? Infinity : 0;
+    const walk = async (currentDir, depth) => {
+      const entries = await promises.readdir(currentDir, { withFileTypes: true });
+      for (const entry of entries) {
+        const entryAbsolutePath = path9__default.default.join(currentDir, entry.name);
+        const entryRelativePath = path9__default.default.relative(absolutePath, entryAbsolutePath) || ".";
+        if (entry.isDirectory()) {
+          const isExcluded = entry.name.match(excludePattern);
+          if (includeDirectoriesNormalized && matchPattern(entry.name) && !isExcluded) {
+            collected.push({
+              name: entry.name,
+              absolutePath: entryAbsolutePath,
+              relativePath: entryRelativePath,
+              type: "directory"
+            });
+          }
+          if (recursive && depth < maxDepthNormalized && !isExcluded) {
+            await walk(entryAbsolutePath, depth + 1);
+          }
+        } else if (entry.isFile()) {
+          if (includeFilesNormalized && matchPattern(entry.name) && !entry.name.match(excludePattern)) {
+            collected.push({
+              name: entry.name,
+              absolutePath: entryAbsolutePath,
+              relativePath: entryRelativePath,
+              type: "file"
+            });
+          }
+        }
+      }
+    };
+    await walk(absolutePath, 0);
+    const totalFiles = collected.filter((item) => item.type === "file").length;
+    const totalDirectories = collected.filter((item) => item.type === "directory").length;
+    let message = `Successfully listed ${collected.length} items in: ${relativePath ?? absolutePath}`;
+    if (recursive) {
+      message += ` (recursive${maxDepth !== void 0 ? `, max depth ${maxDepth}` : ""})`;
+    }
+    if (pattern) {
+      message += ` (filtered by pattern: ${pattern})`;
+    }
+    message += ` - ${totalFiles} files, ${totalDirectories} directories`;
+    return {
+      success: true,
+      message,
+      files: collected
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed to list files: ${error}`,
+      error: "LIST_ERROR"
+    };
+  }
+};
+var ignoreFiles = ["node_modules", ".git", ".next", ".env", ".env.local", ".env.development.local", ".env.test.local", ".env.production.local"];
+var getContext = (dir, base = dir, allFiles = []) => {
+  const filePath = fs3.readdirSync(dir, { withFileTypes: true });
+  for (const file of filePath) {
+    if (ignoreFiles.includes(file.name)) continue;
+    const fullPath = path9__default.default.join(dir, file.name);
+    if (file.isDirectory()) {
+      getContext(fullPath, base, allFiles);
+    } else {
+      allFiles.push(path9__default.default.relative(base, fullPath));
+    }
+  }
+  return allFiles;
+};
+var HOME = os2__default.default.homedir();
+var IDE_PROJECTS_PATHS = {
+  vscode: path9__default.default.join(HOME, ".vscode", "projects"),
+  cursor: path9__default.default.join(HOME, ".cursor", "projects"),
+  claude: path9__default.default.join(HOME, ".claude", "projects")
+};
+function getWorkspaceStoragePath(ide) {
+  const platform = os2__default.default.platform();
+  const appName = "Cursor" ;
+  if (platform === "darwin") {
+    return path9__default.default.join(HOME, "Library", "Application Support", appName, "User", "workspaceStorage");
+  } else if (platform === "win32") {
+    return path9__default.default.join(process.env.APPDATA || "", appName, "User", "workspaceStorage");
+  } else {
+    return path9__default.default.join(HOME, ".config", appName, "User", "workspaceStorage");
+  }
+}
+function scanWorkspaceStorage(ide) {
+  const projects = [];
+  const storagePath = getWorkspaceStoragePath();
+  if (!fs3__default.default.existsSync(storagePath)) {
+    return projects;
+  }
+  try {
+    const workspaces = fs3__default.default.readdirSync(storagePath);
+    for (const workspace of workspaces) {
+      const workspaceJsonPath = path9__default.default.join(storagePath, workspace, "workspace.json");
+      if (fs3__default.default.existsSync(workspaceJsonPath)) {
+        try {
+          const content = fs3__default.default.readFileSync(workspaceJsonPath, "utf-8");
+          const data = JSON.parse(content);
+          if (data.folder && typeof data.folder === "string") {
+            let projectPath = data.folder;
+            if (projectPath.startsWith("file://")) {
+              projectPath = projectPath.replace("file://", "");
+              projectPath = decodeURIComponent(projectPath);
+            }
+            if (fs3__default.default.existsSync(projectPath) && fs3__default.default.statSync(projectPath).isDirectory()) {
+              projects.push({
+                name: path9__default.default.basename(projectPath),
+                path: projectPath,
+                type: ide
+              });
+            }
+          }
+        } catch (err) {
+          console.debug(`Error reading workspace.json at ${workspaceJsonPath}: ${err}`);
+        }
+      }
+    }
+  } catch (err) {
+    console.debug(`Error scanning workspaceStorage for ${ide}: ${err}`);
+  }
+  return projects;
+}
+var scanIdeProjects = async () => {
+  try {
+    const allProjects = [];
+    const seenPaths = /* @__PURE__ */ new Set();
+    const addProject = (projectPath, ide) => {
+      try {
+        const resolvedPath = fs3__default.default.realpathSync(projectPath);
+        if (fs3__default.default.existsSync(resolvedPath) && fs3__default.default.statSync(resolvedPath).isDirectory() && !seenPaths.has(resolvedPath)) {
+          const isIdeProjectsDir = Object.values(IDE_PROJECTS_PATHS).some((ideDir) => {
+            try {
+              return fs3__default.default.realpathSync(ideDir) === resolvedPath;
+            } catch {
+              return false;
+            }
+          });
+          if (!isIdeProjectsDir) {
+            seenPaths.add(resolvedPath);
+            allProjects.push({
+              name: path9__default.default.basename(resolvedPath),
+              path: resolvedPath,
+              type: ide
+            });
+          }
+        }
+      } catch {
+      }
+    };
+    const cursorProjects = scanWorkspaceStorage("cursor");
+    for (const project of cursorProjects) {
+      addProject(project.path, "cursor");
+    }
+    for (const [ide, dirPath] of Object.entries(IDE_PROJECTS_PATHS)) {
+      if (ide === "cursor") continue;
+      if (fs3__default.default.existsSync(dirPath)) {
+        const projects = fs3__default.default.readdirSync(dirPath);
+        projects.forEach((project) => {
+          const projectPath = path9__default.default.join(dirPath, project);
+          try {
+            const stats = fs3__default.default.lstatSync(projectPath);
+            let actualPath = null;
+            if (stats.isSymbolicLink()) {
+              actualPath = fs3__default.default.realpathSync(projectPath);
+            } else if (stats.isFile()) {
+              try {
+                let content = fs3__default.default.readFileSync(projectPath, "utf-8").trim();
+                if (content.startsWith("~/") || content === "~") {
+                  content = content.replace(/^~/, HOME);
+                }
+                const resolvedContent = path9__default.default.isAbsolute(content) ? content : path9__default.default.resolve(path9__default.default.dirname(projectPath), content);
+                if (fs3__default.default.existsSync(resolvedContent) && fs3__default.default.statSync(resolvedContent).isDirectory()) {
+                  actualPath = fs3__default.default.realpathSync(resolvedContent);
+                }
+              } catch {
+                return;
+              }
+            } else if (stats.isDirectory()) {
+              actualPath = fs3__default.default.realpathSync(projectPath);
+            }
+            if (actualPath) {
+              addProject(actualPath, ide);
+            }
+          } catch {
+          }
+        });
+      }
+    }
+    return allProjects;
+  } catch (error) {
+    console.debug(`Error scanning IDE projects: ${error}`);
+    return [];
+  }
+};
+var wsConnection = null;
+var startHttpServer = (connection) => {
+  if (connection) {
+    wsConnection = connection;
+  }
+  const app = new hono.Hono();
+  app.use(cors.cors());
+  app.post("/daemon/status/stream", (c) => {
+    const status = wsConnection ? getConnectionStatus(wsConnection) : "closed";
+    return c.json({ connected: status === "open" });
+  });
+  app.get("context", async (c) => {
+    const context = getContext(process.cwd());
+    return c.body(JSON.stringify(context));
+  });
+  app.get("/ide-projects", async (c) => {
+    try {
+      const projects = await scanIdeProjects();
+      if (!projects) {
+        return c.json({ error: "No projects found" }, 500);
+      }
+      return c.json({ projects });
+    } catch (error) {
+      return c.json({ error: "Failed to scan IDE projects" }, 500);
+    }
+  });
+  app.post("/projects/register", async (c) => {
+    try {
+      const { projectId, cwd, name } = await c.req.json();
+      if (!projectId || !cwd) {
+        return c.json({ error: "projectId and cwd are required" }, 400);
+      }
+      projectRegistry.register(projectId, cwd, name);
+      return c.json({ success: true, projectId, cwd });
+    } catch (error) {
+      return c.json({ error: error.message || "Failed to register project" }, 500);
+    }
+  });
+  app.post("/revert", async (c) => {
+    try {
+      const { filePath, oldString, newString, projectCwd } = await c.req.json();
+      if (!filePath || oldString === void 0) {
+        return c.json({ error: "filePath and oldString required" }, 400);
+      }
+      let resolved;
+      if (projectCwd) {
+        resolved = path9__default.default.isAbsolute(filePath) ? filePath : path9__default.default.resolve(projectCwd, filePath);
+        const normalizedResolved = path9__default.default.normalize(resolved);
+        const normalizedCwd = path9__default.default.normalize(projectCwd);
+        if (!normalizedResolved.startsWith(normalizedCwd)) {
+          return c.json({ error: "Path is outside project directory" }, 403);
+        }
+      } else {
+        resolved = path9__default.default.isAbsolute(filePath) ? filePath : path9__default.default.join(process.cwd(), filePath);
+      }
+      let currentContent;
+      try {
+        currentContent = await promises.readFile(resolved, "utf-8");
+      } catch (error) {
+        if (error?.code === "ENOENT") {
+          return c.json({ error: `File not found: ${filePath}` }, 404);
+        }
+        return c.json({ error: `Failed to read file: ${error.message}` }, 500);
+      }
+      let finalContent;
+      if (newString && newString !== oldString) {
+        if (!currentContent.includes(newString)) {
+          return c.json({ error: "Cannot revert: the new content is not found in the current file. The file may have been modified." }, 400);
+        }
+        const occurrences = currentContent.split(newString).length - 1;
+        if (occurrences > 1) {
+          return c.json({ error: "Cannot revert: the new content appears multiple times in the file" }, 400);
+        }
+        finalContent = currentContent.replace(newString, oldString);
+      } else {
+        finalContent = oldString;
+      }
+      await promises.writeFile(resolved, finalContent, "utf-8");
+      return c.json({ success: true });
+    } catch (error) {
+      return c.json({ error: error.message }, 500);
+    }
+  });
+  app.get("/projects", (c) => {
+    const projects = projectRegistry.list();
+    return c.json({ projects });
+  });
+  app.get("/projects/:projectId", (c) => {
+    const projectId = c.req.param("projectId");
+    const project = projectRegistry.getProject(projectId);
+    if (!project) {
+      return c.json({ error: "Project not found" }, 404);
+    }
+    return c.json({ project });
+  });
+  app.delete("/projects/:projectId", (c) => {
+    const projectId = c.req.param("projectId");
+    projectRegistry.unregister(projectId);
+    return c.json({ success: true });
+  });
+  nodeServer.serve({ fetch: app.fetch, port: 3456 });
+};
+var CREDENTIALS_DIR = path9__default.default.join(os2__default.default.homedir(), ".ama");
+var CREDENTIALS_PATH = path9__default.default.join(CREDENTIALS_DIR, "credentials.json");
+function getTokens() {
+  if (!fs3__default.default.existsSync(CREDENTIALS_PATH)) {
+    return null;
+  }
+  const raw = fs3__default.default.readFileSync(CREDENTIALS_PATH, "utf8");
+  const data = JSON.parse(raw);
+  return data;
+}
+
+// src/server.ts
+var toolExecutors = {
+  editFile: editFiles,
+  deleteFile,
+  grep: grepTool,
+  glob: globTool,
+  listDirectory: list,
+  readFile: read_file,
+  stringReplace: apply_patch
+};
+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";
+}
+function connectToServer2(serverUrl = DEFAULT_SERVER_URL) {
+  const tokens = getTokens();
+  if (!tokens) {
+    throw new Error("No tokens found");
+  }
+  const wsUrl = `${serverUrl}/agent-streams`;
+  const ws = new WebSocket__default.default(wsUrl, {
+    headers: {
+      "Authorization": `Bearer ${tokens.access_token}`
+    }
+  });
+  ws.on("open", () => {
+    console.log(pc2__default.default.green("Connected to server agent streams"));
+  });
+  ws.on("message", async (data) => {
+    const message = JSON.parse(data.toString());
+    if (message.type === "tool_call") {
+      console.log(`Executing tool: ${message.tool}${message.projectCwd ? ` (project: ${message.projectCwd})` : ""}`);
+      try {
+        const executor = toolExecutors[message.tool];
+        if (!executor) {
+          throw new Error(`Unknown tool: ${message.tool}`);
+        }
+        const result = await executor(message.args, message.projectCwd);
+        ws.send(JSON.stringify({
+          type: "tool_result",
+          id: message.id,
+          result
+        }));
+        console.log(pc2__default.default.green(`Tool completed: ${message.tool}`));
+      } catch (error) {
+        ws.send(JSON.stringify({
+          type: "tool_result",
+          id: message.id,
+          error: error.message
+        }));
+        console.error(pc2__default.default.red(`Tool failed: ${message.tool} ${error.message}`));
+      }
+    }
+  });
+  ws.on("close", () => {
+    console.log(pc2__default.default.red("Disconnected from server. Reconnecting in 5s..."));
+    setTimeout(() => connectToServer2(serverUrl), 5e3);
+  });
+  ws.on("error", (error) => {
+    console.error(pc2__default.default.red(`WebSocket error: ${error.message}`));
+  });
+  return ws;
+}
+async function main() {
+  const serverUrl = DEFAULT_SERVER_URL;
+  console.log(pc2__default.default.green("Starting local ama-agent..."));
+  console.log(pc2__default.default.gray(`Connecting to server at ${serverUrl}`));
+  const connection = connectToServer2(serverUrl);
+  startHttpServer(connection);
+}
+
+exports.connectToServer = connectToServer2;
+exports.getConnectionStatus = getConnectionStatus;
+exports.main = main;