amai 0.0.1

package/dist/lib/daemon-entry.js

@@ -0,0 +1,1578 @@
+#!/usr/bin/env node
+import WebSocket from 'ws';
+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, spawn } from 'child_process';
+import { promisify } from 'util';
+import pc2 from 'picocolors';
+import { Hono } from 'hono';
+import { serve } from '@hono/node-server';
+import { cors } from 'hono/cors';
+
+var DEFAULT_SERVER_URL = "wss://ama-production-a628.up.railway.app";
+var AMA_DIR = path9.join(os2.homedir(), ".ama");
+var CODE_DIR = path9.join(AMA_DIR, "code");
+var STORAGE_DIR = path9.join(AMA_DIR, "storage");
+
+// src/lib/project-registry.ts
+var REGISTRY_FILE = path9.join(AMA_DIR, "projects.json");
+var ProjectRegistry = class {
+  projects = /* @__PURE__ */ new Map();
+  constructor() {
+    this.load();
+  }
+  load() {
+    try {
+      if (fs3.existsSync(REGISTRY_FILE)) {
+        const data = fs3.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.copyFileSync(REGISTRY_FILE, backupFile);
+          fs3.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.existsSync(REGISTRY_FILE)) {
+        try {
+          const backupFile = REGISTRY_FILE + ".backup." + Date.now();
+          fs3.copyFileSync(REGISTRY_FILE, backupFile);
+          fs3.unlinkSync(REGISTRY_FILE);
+          console.log("Corrupted registry file backed up and removed. Starting fresh.");
+        } catch (backupError) {
+        }
+      }
+    }
+  }
+  save() {
+    try {
+      if (!fs3.existsSync(AMA_DIR)) {
+        fs3.mkdirSync(AMA_DIR, { recursive: true });
+      }
+      const projects = Array.from(this.projects.values());
+      fs3.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.normalize(path9.resolve(cwd));
+    this.projects.set(projectId, {
+      id: projectId,
+      cwd: normalizedCwd,
+      name: name || path9.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.resolve(projectCwd, filePath);
+    const normalized = path9.normalize(resolved);
+    const normalizedCwd = path9.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.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.resolve(projectCwd, filePath);
+}
+
+// src/tools/read-file.ts
+z.object({
+  relative_file_path: z.string().describe("The relative path to the file to read."),
+  should_read_entire_file: z.boolean().describe("Whether to read the entire file."),
+  start_line_one_indexed: z.number().optional().describe(
+    "The one-indexed line number to start reading from (inclusive)."
+  ),
+  end_line_one_indexed: 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 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 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.resolve(relative_file_path);
+      try {
+        const fileStats = await 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 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 exec3() {
+        setTimeout(function() {
+          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
+            return callback(void 0);
+          }
+          if (!execEditLength()) {
+            exec3();
+          }
+        }, 0);
+      })();
+    } else {
+      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
+        const ret = execEditLength();
+        if (ret) {
+          return ret;
+        }
+      }
+    }
+  }
+  addToPath(path13, added, removed, oldPosInc, options) {
+    const last = path13.lastComponent;
+    if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
+      return {
+        oldPos: path13.oldPos + oldPosInc,
+        lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
+      };
+    } else {
+      return {
+        oldPos: path13.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
+z.object({
+  file_path: 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: z.string().describe("The edited text to replace the old_string (must be different from the old_string)"),
+  old_string: 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 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 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"
+    };
+  }
+};
+z.object({
+  target_file: 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: z.string().describe("The content to write to the file"),
+  providedNewFile: 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.dirname(filePath);
+    await mkdir(dirPath, { recursive: true });
+    let isNewFile = providedNewFile;
+    let existingContent = "";
+    if (isNewFile === void 0) {
+      try {
+        existingContent = await fs3.promises.readFile(filePath, "utf-8");
+        isNewFile = false;
+      } catch (error) {
+        isNewFile = true;
+      }
+    } else if (!isNewFile) {
+      try {
+        existingContent = await fs3.promises.readFile(filePath, "utf-8");
+      } catch (error) {
+        isNewFile = true;
+      }
+    }
+    await fs3.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}`
+    };
+  }
+};
+z.object({
+  path: 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 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 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"
+    };
+  }
+};
+z.object({
+  query: z.string().describe("The regex pattern to search for"),
+  options: z.object({
+    includePattern: z.string().optional().describe('Glob pattern for files to include (e.g., "*.ts")'),
+    excludePattern: z.string().optional().describe("Glob pattern for files to exclude"),
+    caseSensitive: z.boolean().optional().describe("Whether the search should be case sensitive")
+  })
+});
+var execAsync = promisify(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.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"
+    };
+  }
+};
+z.object({
+  pattern: z.string().describe('Glob pattern (e.g., "**/*.js")'),
+  path: 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 = 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("|");
+z.object({
+  path: z.string().optional(),
+  recursive: z.boolean().optional().describe("Whether to list files recursively"),
+  maxDepth: z.number().optional().describe("Maximum recursion depth (default: unlimited)"),
+  pattern: z.string().optional().describe("File extension (e.g., '.ts') or glob-like pattern"),
+  includeDirectories: z.boolean().optional().describe("Whether to include directories in results (default: true)"),
+  includeFiles: 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 access(absolutePath);
+    } catch {
+      return {
+        success: false,
+        message: `File does not exist: ${absolutePath}`,
+        error: "FILE_DOES_NOT_EXIST"
+      };
+    }
+    const isDir = (await 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 readdir(currentDir, { withFileTypes: true });
+      for (const entry of entries) {
+        const entryAbsolutePath = path9.join(currentDir, entry.name);
+        const entryRelativePath = path9.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 = readdirSync(dir, { withFileTypes: true });
+  for (const file of filePath) {
+    if (ignoreFiles.includes(file.name)) continue;
+    const fullPath = path9.join(dir, file.name);
+    if (file.isDirectory()) {
+      getContext(fullPath, base, allFiles);
+    } else {
+      allFiles.push(path9.relative(base, fullPath));
+    }
+  }
+  return allFiles;
+};
+var HOME = os2.homedir();
+var IDE_PROJECTS_PATHS = {
+  vscode: path9.join(HOME, ".vscode", "projects"),
+  cursor: path9.join(HOME, ".cursor", "projects"),
+  claude: path9.join(HOME, ".claude", "projects")
+};
+function getWorkspaceStoragePath(ide) {
+  const platform = os2.platform();
+  const appName = "Cursor" ;
+  if (platform === "darwin") {
+    return path9.join(HOME, "Library", "Application Support", appName, "User", "workspaceStorage");
+  } else if (platform === "win32") {
+    return path9.join(process.env.APPDATA || "", appName, "User", "workspaceStorage");
+  } else {
+    return path9.join(HOME, ".config", appName, "User", "workspaceStorage");
+  }
+}
+function scanWorkspaceStorage(ide) {
+  const projects = [];
+  const storagePath = getWorkspaceStoragePath();
+  if (!fs3.existsSync(storagePath)) {
+    return projects;
+  }
+  try {
+    const workspaces = fs3.readdirSync(storagePath);
+    for (const workspace of workspaces) {
+      const workspaceJsonPath = path9.join(storagePath, workspace, "workspace.json");
+      if (fs3.existsSync(workspaceJsonPath)) {
+        try {
+          const content = fs3.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.existsSync(projectPath) && fs3.statSync(projectPath).isDirectory()) {
+              projects.push({
+                name: path9.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.realpathSync(projectPath);
+        if (fs3.existsSync(resolvedPath) && fs3.statSync(resolvedPath).isDirectory() && !seenPaths.has(resolvedPath)) {
+          const isIdeProjectsDir = Object.values(IDE_PROJECTS_PATHS).some((ideDir) => {
+            try {
+              return fs3.realpathSync(ideDir) === resolvedPath;
+            } catch {
+              return false;
+            }
+          });
+          if (!isIdeProjectsDir) {
+            seenPaths.add(resolvedPath);
+            allProjects.push({
+              name: path9.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.existsSync(dirPath)) {
+        const projects = fs3.readdirSync(dirPath);
+        projects.forEach((project) => {
+          const projectPath = path9.join(dirPath, project);
+          try {
+            const stats = fs3.lstatSync(projectPath);
+            let actualPath = null;
+            if (stats.isSymbolicLink()) {
+              actualPath = fs3.realpathSync(projectPath);
+            } else if (stats.isFile()) {
+              try {
+                let content = fs3.readFileSync(projectPath, "utf-8").trim();
+                if (content.startsWith("~/") || content === "~") {
+                  content = content.replace(/^~/, HOME);
+                }
+                const resolvedContent = path9.isAbsolute(content) ? content : path9.resolve(path9.dirname(projectPath), content);
+                if (fs3.existsSync(resolvedContent) && fs3.statSync(resolvedContent).isDirectory()) {
+                  actualPath = fs3.realpathSync(resolvedContent);
+                }
+              } catch {
+                return;
+              }
+            } else if (stats.isDirectory()) {
+              actualPath = fs3.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();
+  app.use(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.isAbsolute(filePath) ? filePath : path9.resolve(projectCwd, filePath);
+        const normalizedResolved = path9.normalize(resolved);
+        const normalizedCwd = path9.normalize(projectCwd);
+        if (!normalizedResolved.startsWith(normalizedCwd)) {
+          return c.json({ error: "Path is outside project directory" }, 403);
+        }
+      } else {
+        resolved = path9.isAbsolute(filePath) ? filePath : path9.join(process.cwd(), filePath);
+      }
+      let currentContent;
+      try {
+        currentContent = await 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 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 });
+  });
+  serve({ fetch: app.fetch, port: 3456 });
+};
+var CREDENTIALS_DIR = path9.join(os2.homedir(), ".ama");
+var CREDENTIALS_PATH = path9.join(CREDENTIALS_DIR, "credentials.json");
+function getTokens() {
+  if (!fs3.existsSync(CREDENTIALS_PATH)) {
+    return null;
+  }
+  const raw = fs3.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.CONNECTING ? "connecting" : ws.readyState === WebSocket.OPEN ? "open" : ws.readyState === WebSocket.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(wsUrl, {
+    headers: {
+      "Authorization": `Bearer ${tokens.access_token}`
+    }
+  });
+  ws.on("open", () => {
+    console.log(pc2.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.green(`Tool completed: ${message.tool}`));
+      } catch (error) {
+        ws.send(JSON.stringify({
+          type: "tool_result",
+          id: message.id,
+          error: error.message
+        }));
+        console.error(pc2.red(`Tool failed: ${message.tool} ${error.message}`));
+      }
+    }
+  });
+  ws.on("close", () => {
+    console.log(pc2.red("Disconnected from server. Reconnecting in 5s..."));
+    setTimeout(() => connectToServer2(serverUrl), 5e3);
+  });
+  ws.on("error", (error) => {
+    console.error(pc2.red(`WebSocket error: ${error.message}`));
+  });
+  return ws;
+}
+async function main() {
+  const serverUrl = DEFAULT_SERVER_URL;
+  console.log(pc2.green("Starting local ama-agent..."));
+  console.log(pc2.gray(`Connecting to server at ${serverUrl}`));
+  const connection = connectToServer2(serverUrl);
+  startHttpServer(connection);
+}
+var execAsync2 = promisify(exec);
+var CODE_SERVER_VERSION = "4.96.4";
+function getPlatformInfo() {
+  const platform = process.platform;
+  const arch = process.arch;
+  if (platform === "darwin") {
+    return {
+      platform: "macos",
+      arch: arch === "arm64" ? "arm64" : "amd64",
+      ext: "tar.gz"
+    };
+  } else if (platform === "linux") {
+    return {
+      platform: "linux",
+      arch: arch === "arm64" ? "arm64" : "amd64",
+      ext: "tar.gz"
+    };
+  } else {
+    throw new Error(`Unsupported platform: ${platform}`);
+  }
+}
+function getDownloadUrl() {
+  const { platform, arch, ext } = getPlatformInfo();
+  return `https://github.com/coder/code-server/releases/download/v${CODE_SERVER_VERSION}/code-server-${CODE_SERVER_VERSION}-${platform}-${arch}.${ext}`;
+}
+function getCodeServerDir() {
+  const { platform, arch } = getPlatformInfo();
+  return path9.join(CODE_DIR, `code-server-${CODE_SERVER_VERSION}-${platform}-${arch}`);
+}
+function getCodeServerBin() {
+  return path9.join(getCodeServerDir(), "bin", "code-server");
+}
+function isCodeServerInstalled() {
+  const binPath = getCodeServerBin();
+  return fs3.existsSync(binPath);
+}
+async function installCodeServer() {
+  const { ext } = getPlatformInfo();
+  const downloadUrl = getDownloadUrl();
+  const tarballPath = path9.join(AMA_DIR, `code-server.${ext}`);
+  if (!fs3.existsSync(AMA_DIR)) {
+    fs3.mkdirSync(AMA_DIR, { recursive: true });
+  }
+  if (!fs3.existsSync(CODE_DIR)) {
+    fs3.mkdirSync(CODE_DIR, { recursive: true });
+  }
+  if (!fs3.existsSync(STORAGE_DIR)) {
+    fs3.mkdirSync(STORAGE_DIR, { recursive: true });
+  }
+  console.log(pc2.cyan(`Downloading code-server v${CODE_SERVER_VERSION}...`));
+  console.log(pc2.gray(downloadUrl));
+  const response = await fetch(downloadUrl);
+  if (!response.ok) {
+    throw new Error(`Failed to download code-server: ${response.statusText}`);
+  }
+  const buffer = await response.arrayBuffer();
+  await fs3.promises.writeFile(tarballPath, Buffer.from(buffer));
+  console.log(pc2.cyan("Extracting code-server..."));
+  await execAsync2(`tar -xzf ${tarballPath} -C ${CODE_DIR}`);
+  await fs3.promises.unlink(tarballPath);
+  const binPath = getCodeServerBin();
+  if (fs3.existsSync(binPath)) {
+    await fs3.promises.chmod(binPath, 493);
+  }
+  console.log(pc2.green("\u2713 code-server installed successfully"));
+}
+async function killExistingCodeServer() {
+  try {
+    if (process.platform === "win32") {
+      await execAsync2("netstat -ano | findstr :8081 | findstr LISTENING").then(async ({ stdout }) => {
+        const pid = stdout.trim().split(/\s+/).pop();
+        if (pid) await execAsync2(`taskkill /PID ${pid} /F`);
+      }).catch(() => {
+      });
+    } else {
+      await execAsync2("lsof -ti:8081").then(async ({ stdout }) => {
+        const pid = stdout.trim();
+        if (pid) await execAsync2(`kill -9 ${pid}`);
+      }).catch(() => {
+      });
+    }
+  } catch {
+  }
+}
+async function startCodeServer(cwd) {
+  const binPath = getCodeServerBin();
+  const workDir = cwd || process.cwd();
+  if (!fs3.existsSync(binPath)) {
+    throw new Error("code-server is not installed. Run installCodeServer() first.");
+  }
+  await killExistingCodeServer();
+  const workspaceStoragePath = path9.join(STORAGE_DIR, "User", "workspaceStorage");
+  path9.join(STORAGE_DIR, "User", "globalStorage");
+  try {
+    if (fs3.existsSync(workspaceStoragePath)) {
+      await fs3.promises.rm(workspaceStoragePath, { recursive: true, force: true });
+    }
+    const stateDbPath = path9.join(STORAGE_DIR, "User", "globalStorage", "state.vscdb");
+    if (fs3.existsSync(stateDbPath)) {
+      await fs3.promises.unlink(stateDbPath);
+    }
+  } catch {
+  }
+  console.log(pc2.cyan(`Starting code-server in ${workDir}...`));
+  const codeServer = spawn(
+    binPath,
+    [
+      "--port",
+      "8081",
+      "--host",
+      "0.0.0.0",
+      "--auth",
+      "none",
+      "--user-data-dir",
+      STORAGE_DIR,
+      "--disable-workspace-trust",
+      workDir
+    ],
+    {
+      stdio: ["ignore", "pipe", "pipe"]
+    }
+  );
+  console.log(pc2.green(`\u2713 code-server running at http://localhost:8081/?folder=${encodeURIComponent(workDir)}`));
+  return codeServer;
+}
+if (process.env.AMA_DAEMON === "1") {
+  (async () => {
+    try {
+      if (!isCodeServerInstalled()) {
+        console.log(pc2.cyan("First run detected. Setting up code-server..."));
+        try {
+          await installCodeServer();
+        } catch (error) {
+          console.error(pc2.red(`Failed to install code-server: ${error.message}`));
+          console.log(pc2.yellow("Continuing without code-server..."));
+        }
+      }
+      if (isCodeServerInstalled()) {
+        try {
+          const projectDir = process.cwd() || os2.homedir();
+          await startCodeServer(projectDir);
+        } catch (error) {
+          console.error(pc2.red(`Failed to start code-server: ${error.message}`));
+        }
+      }
+      await main();
+    } catch (error) {
+      console.error("Daemon error:", error);
+      process.exit(1);
+    }
+  })();
+} else {
+  console.error("This script should only be run as a daemon");
+  process.exit(1);
+}