amai 0.0.5 → 0.0.7

package/dist/cli.cjs

@@ -1,14 +1,13 @@
 #!/usr/bin/env node
 'use strict';
 
-var pc4 = require('picocolors');
+var pc5 = require('picocolors');
 var WebSocket = require('ws');
-var events = require('events');
 var zod = require('zod');
 var promises = require('fs/promises');
-var path9 = require('path');
-var fs3 = require('fs');
-var os2 = require('os');
+var path11 = require('path');
+var fs4 = require('fs');
+var os3 = require('os');
 var crypto = require('crypto');
 var child_process = require('child_process');
 var util = require('util');
@@ -21,21 +20,21 @@ var readline = require('readline');
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var pc4__default = /*#__PURE__*/_interopDefault(pc4);
+var pc5__default = /*#__PURE__*/_interopDefault(pc5);
 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 path11__default = /*#__PURE__*/_interopDefault(path11);
+var fs4__default = /*#__PURE__*/_interopDefault(fs4);
+var os3__default = /*#__PURE__*/_interopDefault(os3);
 var readline__default = /*#__PURE__*/_interopDefault(readline);
 
 var DEFAULT_SERVER_URL = "wss://ama-production-a628.up.railway.app";
 var CLIENT_ID = "client_01K4Y8A67H544Z6J8A47E5GJ9A";
-var AMA_DIR = path9__default.default.join(os2__default.default.homedir(), ".amai");
-var CODE_DIR = path9__default.default.join(AMA_DIR, "code");
-var STORAGE_DIR = path9__default.default.join(AMA_DIR, "storage");
+var AMA_DIR = path11__default.default.join(os3__default.default.homedir(), ".amai");
+var CODE_DIR = path11__default.default.join(AMA_DIR, "code");
+var STORAGE_DIR = path11__default.default.join(AMA_DIR, "storage");
 
 // src/lib/project-registry.ts
-var REGISTRY_FILE = path9__default.default.join(AMA_DIR, "projects.json");
+var REGISTRY_FILE = path11__default.default.join(AMA_DIR, "projects.json");
 var ProjectRegistry = class {
   projects = /* @__PURE__ */ new Map();
   constructor() {
@@ -43,14 +42,14 @@ var ProjectRegistry = class {
   }
   load() {
     try {
-      if (fs3__default.default.existsSync(REGISTRY_FILE)) {
-        const data = fs3__default.default.readFileSync(REGISTRY_FILE, "utf8");
+      if (fs4__default.default.existsSync(REGISTRY_FILE)) {
+        const data = fs4__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);
+          fs4__default.default.copyFileSync(REGISTRY_FILE, backupFile);
+          fs4__default.default.unlinkSync(REGISTRY_FILE);
           return;
         }
         const projects = parsed;
@@ -63,11 +62,11 @@ var ProjectRegistry = class {
       }
     } catch (error) {
       console.error("Failed to load project registry:", error);
-      if (fs3__default.default.existsSync(REGISTRY_FILE)) {
+      if (fs4__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);
+          fs4__default.default.copyFileSync(REGISTRY_FILE, backupFile);
+          fs4__default.default.unlinkSync(REGISTRY_FILE);
           console.log("Corrupted registry file backed up and removed. Starting fresh.");
         } catch (backupError) {
         }
@@ -76,21 +75,21 @@ var ProjectRegistry = class {
   }
   save() {
     try {
-      if (!fs3__default.default.existsSync(AMA_DIR)) {
-        fs3__default.default.mkdirSync(AMA_DIR, { recursive: true });
+      if (!fs4__default.default.existsSync(AMA_DIR)) {
+        fs4__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");
+      fs4__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));
+    const normalizedCwd = path11__default.default.normalize(path11__default.default.resolve(cwd));
     this.projects.set(projectId, {
       id: projectId,
       cwd: normalizedCwd,
-      name: name || path9__default.default.basename(normalizedCwd),
+      name: name || path11__default.default.basename(normalizedCwd),
       active: true
     });
     this.save();
@@ -120,9 +119,9 @@ var ProjectRegistry = class {
 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);
+    const resolved = path11__default.default.resolve(projectCwd, filePath);
+    const normalized = path11__default.default.normalize(resolved);
+    const normalizedCwd = path11__default.default.normalize(projectCwd);
     return normalized.startsWith(normalizedCwd);
   } catch {
     return false;
@@ -138,7 +137,7 @@ function validatePath(filePath, projectCwd) {
     };
   }
   try {
-    const resolvedPath = path9__default.default.resolve(projectCwd, filePath);
+    const resolvedPath = path11__default.default.resolve(projectCwd, filePath);
     if (!isPathWithinProject(filePath, projectCwd)) {
       return {
         valid: false,
@@ -157,7 +156,7 @@ function validatePath(filePath, projectCwd) {
   }
 }
 function resolveProjectPath(filePath, projectCwd) {
-  return path9__default.default.resolve(projectCwd, filePath);
+  return path11__default.default.resolve(projectCwd, filePath);
 }
 
 // src/tools/read-file.ts
@@ -279,7 +278,7 @@ var read_file = async function(input, projectCwd) {
         };
       }
     } else {
-      const absolute_file_path = path9__default.default.resolve(relative_file_path);
+      const absolute_file_path = path11__default.default.resolve(relative_file_path);
       try {
         const fileStats = await promises.stat(absolute_file_path);
         if (!fileStats.isFile()) {
@@ -873,20 +872,20 @@ var editFiles = async function(input, projectCwd) {
     }
     const basePath = projectCwd || process.cwd();
     const filePath = resolveProjectPath(target_file, basePath);
-    const dirPath = path9__default.default.dirname(filePath);
+    const dirPath = path11__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");
+        existingContent = await fs4__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");
+        existingContent = await fs4__default.default.promises.readFile(filePath, "utf-8");
       } catch (error) {
         isNewFile = true;
       }
@@ -899,7 +898,7 @@ var editFiles = async function(input, projectCwd) {
       content
     );
     try {
-      await fs3__default.default.promises.writeFile(filePath, content);
+      await fs4__default.default.promises.writeFile(filePath, content);
     } catch (writeError) {
       checkpointStore.removeCheckpoint(checkpointId);
       throw writeError;
@@ -1023,7 +1022,7 @@ var grepTool = async function(input, projectCwd) {
   try {
     const { includePattern, excludePattern: excludePattern2, caseSensitive } = options || {};
     const searchDir = projectCwd || process.cwd();
-    if (projectCwd && !path9__default.default.isAbsolute(projectCwd)) {
+    if (projectCwd && !path11__default.default.isAbsolute(projectCwd)) {
       return {
         success: false,
         message: "Invalid project directory",
@@ -1215,8 +1214,8 @@ var list = async function(input, projectCwd) {
     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) || ".";
+        const entryAbsolutePath = path11__default.default.join(currentDir, entry.name);
+        const entryRelativePath = path11__default.default.relative(absolutePath, entryAbsolutePath) || ".";
         if (entry.isDirectory()) {
           const isExcluded = entry.name.match(excludePattern);
           if (includeDirectoriesNormalized && matchPattern(entry.name) && !isExcluded) {
@@ -1266,213 +1265,9 @@ var list = async function(input, projectCwd) {
     };
   }
 };
-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;
-  }
+var startHttpServer = () => {
   const app = new hono.Hono();
   app.use(cors.cors());
-  app.post("/daemon/status", (c) => {
-    const status = wsConnection ? getConnectionStatus(wsConnection) : "closed";
-    return c.json({ connected: status === "open" });
-  });
-  app.get("/daemon/status/stream", (c) => {
-    const encoder = new TextEncoder();
-    const stream = new ReadableStream({
-      start(controller) {
-        const initialStatus = wsConnection ? getConnectionStatus(wsConnection) : "closed";
-        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ connected: initialStatus === "open" })}
-
-`));
-        const statusHandler = (data) => {
-          try {
-            controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
-
-`));
-          } catch {
-          }
-        };
-        statusEmitter.on("status", statusHandler);
-        const heartbeatInterval = setInterval(() => {
-          try {
-            const currentStatus = wsConnection ? getConnectionStatus(wsConnection) : "closed";
-            controller.enqueue(encoder.encode(`data: ${JSON.stringify({ connected: currentStatus === "open" })}
-
-`));
-          } catch {
-          }
-        }, 15e3);
-        c.req.raw.signal.addEventListener("abort", () => {
-          statusEmitter.off("status", statusHandler);
-          clearInterval(heartbeatInterval);
-        });
-      }
-    });
-    return new Response(stream, {
-      headers: {
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache",
-        "Connection": "keep-alive"
-      }
-    });
-  });
-  app.get("context", async (c) => {
-    const context = getContext(process.cwd());
-    return c.body(JSON.stringify(context));
-  });
-  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();
@@ -1501,14 +1296,14 @@ var startHttpServer = (connection) => {
       }
       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);
+        resolved = path11__default.default.isAbsolute(filePath) ? filePath : path11__default.default.resolve(projectCwd, filePath);
+        const normalizedResolved = path11__default.default.normalize(resolved);
+        const normalizedCwd = path11__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);
+        resolved = path11__default.default.isAbsolute(filePath) ? filePath : path11__default.default.join(process.cwd(), filePath);
       }
       let currentContent;
       try {
@@ -1595,9 +1390,9 @@ var startHttpServer = (connection) => {
       }
       let resolved;
       if (projectCwd) {
-        resolved = path9__default.default.isAbsolute(filePath || checkpoint.filePath) ? filePath || checkpoint.filePath : path9__default.default.resolve(projectCwd, filePath || checkpoint.filePath);
-        const normalizedResolved = path9__default.default.normalize(resolved);
-        const normalizedCwd = path9__default.default.normalize(projectCwd);
+        resolved = path11__default.default.isAbsolute(filePath || checkpoint.filePath) ? filePath || checkpoint.filePath : path11__default.default.resolve(projectCwd, filePath || checkpoint.filePath);
+        const normalizedResolved = path11__default.default.normalize(resolved);
+        const normalizedCwd = path11__default.default.normalize(projectCwd);
         if (!normalizedResolved.startsWith(normalizedCwd)) {
           return c.json({ error: "Path is outside project directory" }, 403);
         }
@@ -1660,14 +1455,14 @@ var startHttpServer = (connection) => {
   nodeServer.serve({ fetch: app.fetch, port: 3456 });
 };
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-var CREDENTIALS_DIR = path9__default.default.join(os2__default.default.homedir(), ".amai");
-var CREDENTIALS_PATH = path9__default.default.join(CREDENTIALS_DIR, "credentials.json");
+var CREDENTIALS_DIR = path11__default.default.join(os3__default.default.homedir(), ".amai");
+var CREDENTIALS_PATH = path11__default.default.join(CREDENTIALS_DIR, "credentials.json");
 function isAuthenticated() {
   try {
-    if (!fs3__default.default.existsSync(CREDENTIALS_PATH)) {
+    if (!fs4__default.default.existsSync(CREDENTIALS_PATH)) {
       return false;
     }
-    const raw = fs3__default.default.readFileSync(CREDENTIALS_PATH, "utf8");
+    const raw = fs4__default.default.readFileSync(CREDENTIALS_PATH, "utf8");
     const data = JSON.parse(raw);
     return Boolean(data && data.access_token);
   } catch {
@@ -1676,32 +1471,32 @@ function isAuthenticated() {
 }
 function saveTokens(tokens) {
   try {
-    if (!fs3__default.default.existsSync(CREDENTIALS_DIR)) {
-      fs3__default.default.mkdirSync(CREDENTIALS_DIR, { recursive: true });
+    if (!fs4__default.default.existsSync(CREDENTIALS_DIR)) {
+      fs4__default.default.mkdirSync(CREDENTIALS_DIR, { recursive: true });
     }
-    fs3__default.default.writeFileSync(
+    fs4__default.default.writeFileSync(
       CREDENTIALS_PATH,
       JSON.stringify(tokens, null, 2),
       "utf8"
     );
   } catch (error) {
-    console.error(pc4__default.default.red("Failed to save credentials"), error);
+    console.error(pc5__default.default.red("Failed to save credentials"), error);
   }
 }
 function logout() {
   try {
-    if (fs3__default.default.existsSync(CREDENTIALS_PATH)) {
-      fs3__default.default.unlinkSync(CREDENTIALS_PATH);
+    if (fs4__default.default.existsSync(CREDENTIALS_PATH)) {
+      fs4__default.default.unlinkSync(CREDENTIALS_PATH);
     }
   } catch (error) {
-    console.error(pc4__default.default.red("Failed to logout"), error);
+    console.error(pc5__default.default.red("Failed to logout"), error);
   }
 }
 function getTokens() {
-  if (!fs3__default.default.existsSync(CREDENTIALS_PATH)) {
+  if (!fs4__default.default.existsSync(CREDENTIALS_PATH)) {
     return null;
   }
-  const raw = fs3__default.default.readFileSync(CREDENTIALS_PATH, "utf8");
+  const raw = fs4__default.default.readFileSync(CREDENTIALS_PATH, "utf8");
   const data = JSON.parse(raw);
   return data;
 }
@@ -1769,27 +1564,27 @@ async function pollForTokens({
 async function login() {
   try {
     const device = await authorizeDevice();
-    console.log(pc4__default.default.bold("To sign in, follow these steps:"));
+    console.log(pc5__default.default.bold("To sign in, follow these steps:"));
     if (device.verification_uri_complete) {
       console.log(
-        `  1. Open this URL in your browser: ${pc4__default.default.cyan(
+        `  1. Open this URL in your browser: ${pc5__default.default.cyan(
           device.verification_uri_complete
         )}`
       );
     } else {
       console.log(
-        `  1. Open this URL in your browser: ${pc4__default.default.cyan(
+        `  1. Open this URL in your browser: ${pc5__default.default.cyan(
           device.verification_uri
         )}`
       );
       console.log(
-        `  2. Enter this code when prompted: ${pc4__default.default.bold(device.user_code)}`
+        `  2. Enter this code when prompted: ${pc5__default.default.bold(device.user_code)}`
       );
     }
     console.log("  3. Come back here; we will detect when you finish logging in.");
     console.log();
     console.log(
-      pc4__default.default.gray(
+      pc5__default.default.gray(
         `Waiting for authorization (expires in ~${Math.round(
           device.expires_in / 60
         )} minutes)...`
@@ -1801,14 +1596,28 @@ async function login() {
       expiresIn: device.expires_in,
       interval: device.interval
     });
-    console.log(pc4__default.default.green("Successfully authenticated!"));
+    console.log(pc5__default.default.green("Successfully authenticated!"));
     saveTokens(tokens);
     return tokens;
   } catch (error) {
-    console.error(pc4__default.default.red(error.message || "Login failed"));
+    console.error(pc5__default.default.red(error.message || "Login failed"));
     throw error;
   }
 }
+var getUserId = () => {
+  try {
+    if (!fs4__default.default.existsSync(CREDENTIALS_PATH)) {
+      return;
+    }
+    const raw = fs4__default.default.readFileSync(CREDENTIALS_PATH, "utf8");
+    const data = JSON.parse(raw);
+    return {
+      userId: data.user.id
+    };
+  } catch {
+    throw new Error("Error while getting userId");
+  }
+};
 var ExplanationSchema = zod.z.object({
   explanation: zod.z.string().describe("One sentence explanation as to why this tool is being used")
 });
@@ -1896,9 +1705,343 @@ var runTerminalCommand = async (input, projectCwd) => {
     };
   }
 };
+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 = fs4.readdirSync(dir, { withFileTypes: true });
+  for (const file of filePath) {
+    if (ignoreFiles.includes(file.name)) continue;
+    const fullPath = path11__default.default.join(dir, file.name);
+    if (file.isDirectory()) {
+      getContext(fullPath, base, allFiles);
+    } else {
+      allFiles.push(path11__default.default.relative(base, fullPath));
+    }
+  }
+  return allFiles;
+};
+var HOME = os3__default.default.homedir();
+var IDE_PROJECTS_PATHS = {
+  vscode: path11__default.default.join(HOME, ".vscode", "projects"),
+  cursor: path11__default.default.join(HOME, ".cursor", "projects"),
+  claude: path11__default.default.join(HOME, ".claude", "projects")
+};
+function getWorkspaceStoragePath(ide) {
+  const platform = os3__default.default.platform();
+  const appName = "Cursor" ;
+  if (platform === "darwin") {
+    return path11__default.default.join(HOME, "Library", "Application Support", appName, "User", "workspaceStorage");
+  } else if (platform === "win32") {
+    return path11__default.default.join(process.env.APPDATA || "", appName, "User", "workspaceStorage");
+  } else {
+    return path11__default.default.join(HOME, ".config", appName, "User", "workspaceStorage");
+  }
+}
+function scanWorkspaceStorage(ide) {
+  const projects = [];
+  const storagePath = getWorkspaceStoragePath();
+  if (!fs4__default.default.existsSync(storagePath)) {
+    return projects;
+  }
+  try {
+    const workspaces = fs4__default.default.readdirSync(storagePath);
+    for (const workspace of workspaces) {
+      const workspaceJsonPath = path11__default.default.join(storagePath, workspace, "workspace.json");
+      if (fs4__default.default.existsSync(workspaceJsonPath)) {
+        try {
+          const content = fs4__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 (fs4__default.default.existsSync(projectPath) && fs4__default.default.statSync(projectPath).isDirectory()) {
+              projects.push({
+                name: path11__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 = fs4__default.default.realpathSync(projectPath);
+        if (fs4__default.default.existsSync(resolvedPath) && fs4__default.default.statSync(resolvedPath).isDirectory() && !seenPaths.has(resolvedPath)) {
+          const isIdeProjectsDir = Object.values(IDE_PROJECTS_PATHS).some((ideDir) => {
+            try {
+              return fs4__default.default.realpathSync(ideDir) === resolvedPath;
+            } catch {
+              return false;
+            }
+          });
+          if (!isIdeProjectsDir) {
+            seenPaths.add(resolvedPath);
+            allProjects.push({
+              name: path11__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 (fs4__default.default.existsSync(dirPath)) {
+        const projects = fs4__default.default.readdirSync(dirPath);
+        projects.forEach((project) => {
+          const projectPath = path11__default.default.join(dirPath, project);
+          try {
+            const stats = fs4__default.default.lstatSync(projectPath);
+            let actualPath = null;
+            if (stats.isSymbolicLink()) {
+              actualPath = fs4__default.default.realpathSync(projectPath);
+            } else if (stats.isFile()) {
+              try {
+                let content = fs4__default.default.readFileSync(projectPath, "utf-8").trim();
+                if (content.startsWith("~/") || content === "~") {
+                  content = content.replace(/^~/, HOME);
+                }
+                const resolvedContent = path11__default.default.isAbsolute(content) ? content : path11__default.default.resolve(path11__default.default.dirname(projectPath), content);
+                if (fs4__default.default.existsSync(resolvedContent) && fs4__default.default.statSync(resolvedContent).isDirectory()) {
+                  actualPath = fs4__default.default.realpathSync(resolvedContent);
+                }
+              } catch {
+                return;
+              }
+            } else if (stats.isDirectory()) {
+              actualPath = fs4__default.default.realpathSync(projectPath);
+            }
+            if (actualPath) {
+              addProject(actualPath, ide);
+            }
+          } catch {
+          }
+        });
+      }
+    }
+    return allProjects;
+  } catch (error) {
+    console.debug(`Error scanning IDE projects: ${error}`);
+    return [];
+  }
+};
+
+// src/lib/rpc-handlers.ts
+var rpcHandlers = {
+  "daemon:get_workspace_folders": async () => {
+    const projects = projectRegistry.list();
+    return {
+      folders: projects.map((p) => ({
+        id: p.id,
+        cwd: p.cwd,
+        name: p.name,
+        active: p.active
+      }))
+    };
+  },
+  "daemon:get_environment": async ({ gitRepositoryUrl }) => {
+    const projects = projectRegistry.list();
+    if (projects.length === 0) {
+      const error = {
+        _tag: "ProjectUnlinkedError",
+        message: `Getting a local project by git repository URL "${gitRepositoryUrl}" returned an unlinked project. Please link it by running \`amai link <project name> <path to project directory>\``
+      };
+      throw error;
+    }
+    return {
+      project: projects[0],
+      env: {
+        platform: process.platform,
+        arch: process.arch,
+        nodeVersion: process.version
+      }
+    };
+  },
+  "daemon:get_context": async ({ cwd }) => {
+    try {
+      const files = getContext(cwd);
+      return { files, cwd };
+    } catch (error) {
+      const rpcError = {
+        _tag: "ContextError",
+        message: error.message || "Failed to get context"
+      };
+      throw rpcError;
+    }
+  },
+  "daemon:get_ide_projects": async () => {
+    const projects = await scanIdeProjects();
+    return { projects };
+  },
+  "daemon:register_project": async ({ projectId, cwd, name }) => {
+    if (!projectId || !cwd) {
+      const error = {
+        _tag: "ValidationError",
+        message: "projectId and cwd are required"
+      };
+      throw error;
+    }
+    projectRegistry.register(projectId, cwd, name);
+    return { success: true, projectId, cwd };
+  },
+  "daemon:unregister_project": async ({ projectId }) => {
+    if (!projectId) {
+      const error = {
+        _tag: "ValidationError",
+        message: "projectId is required"
+      };
+      throw error;
+    }
+    projectRegistry.unregister(projectId);
+    return { success: true, projectId };
+  },
+  "daemon:get_project": async ({ projectId }) => {
+    const project = projectRegistry.getProject(projectId);
+    if (!project) {
+      const error = {
+        _tag: "ProjectNotFoundError",
+        message: `Project not found: ${projectId}`
+      };
+      throw error;
+    }
+    return { project };
+  },
+  "daemon:list_projects": async () => {
+    const projects = projectRegistry.list();
+    return { projects };
+  },
+  "daemon:status": async () => {
+    return {
+      connected: true,
+      timestamp: Date.now(),
+      platform: process.platform,
+      arch: process.arch
+    };
+  }
+};
+var reconnectTimeout = null;
+var connectToUserStreams = async (serverUrl) => {
+  const userId = getUserId();
+  if (!userId?.userId) {
+    throw new Error("User ID not found");
+  }
+  const params = new URLSearchParams({
+    userId: userId.userId,
+    type: "cli"
+  });
+  const tokens = getTokens();
+  if (!tokens) {
+    throw new Error("No tokens found");
+  }
+  const wsUrl = `${serverUrl}/api/v1/user-streams?${params.toString()}`;
+  const ws = new WebSocket__default.default(wsUrl, {
+    headers: {
+      Authorization: `Bearer ${tokens.access_token}`
+    }
+  });
+  ws.on("open", () => {
+    console.log(pc5__default.default.green("CLI connected to user-streams"));
+    if (reconnectTimeout) {
+      clearTimeout(reconnectTimeout);
+      reconnectTimeout = null;
+    }
+  });
+  ws.on("message", async (event) => {
+    try {
+      const message = JSON.parse(event.toString());
+      if (message._tag === "rpc_call") {
+        const { requestId, method, input } = message;
+        console.log(pc5__default.default.gray(`RPC call: ${method}`));
+        const handler = rpcHandlers[method];
+        if (!handler) {
+          ws.send(JSON.stringify({
+            _tag: "rpc_result",
+            requestId,
+            data: {
+              _tag: "UnknownMethodError",
+              message: `Unknown RPC method: ${method}`
+            }
+          }));
+          console.log(pc5__default.default.yellow(`Unknown RPC method: ${method}`));
+          return;
+        }
+        try {
+          const result = await handler(input || {});
+          ws.send(JSON.stringify({
+            _tag: "rpc_result",
+            requestId,
+            data: result
+          }));
+          console.log(pc5__default.default.green(`RPC completed: ${method}`));
+        } catch (error) {
+          const rpcError = error._tag ? error : {
+            _tag: "RpcError",
+            message: error.message || String(error)
+          };
+          ws.send(JSON.stringify({
+            _tag: "rpc_result",
+            requestId,
+            data: rpcError
+          }));
+          console.log(pc5__default.default.red(`RPC failed: ${method} - ${rpcError.message}`));
+        }
+        return;
+      }
+      if (message.type === "presence_request") {
+        if (message.status === "connected") {
+          ws.send(JSON.stringify({
+            type: "presence_request",
+            status: "connected"
+          }));
+        }
+        if (message.status === "disconnected") {
+          ws.send(JSON.stringify({
+            type: "presence_request",
+            status: "disconnected"
+          }));
+        }
+      }
+    } catch (parseError) {
+      console.error(pc5__default.default.red(`Failed to parse message: ${parseError}`));
+    }
+  });
+  ws.on("close", (code, reason) => {
+    console.log(pc5__default.default.yellow(`CLI disconnected from user-streams (code: ${code})`));
+    console.log(pc5__default.default.gray("Reconnecting in 5 seconds..."));
+    reconnectTimeout = setTimeout(() => {
+      connectToUserStreams(serverUrl).catch((err) => {
+        console.error(pc5__default.default.red(`Reconnection failed: ${err.message}`));
+      });
+    }, 5e3);
+  });
+  ws.on("error", (error) => {
+    console.error(pc5__default.default.red(`User streams WebSocket error: ${error.message}`));
+  });
+  return ws;
+};
 
 // src/server.ts
-var statusEmitter = new events.EventEmitter();
 var toolExecutors = {
   editFile: editFiles,
   deleteFile,
@@ -1909,10 +2052,7 @@ var toolExecutors = {
   stringReplace: apply_patch,
   runTerminalCommand
 };
-function getConnectionStatus(ws) {
-  return ws.readyState === WebSocket__default.default.CONNECTING ? "connecting" : ws.readyState === WebSocket__default.default.OPEN ? "open" : ws.readyState === WebSocket__default.default.CLOSING ? "closing" : "closed";
-}
-function connectToServer2(serverUrl = DEFAULT_SERVER_URL) {
+function connectToServer(serverUrl = DEFAULT_SERVER_URL) {
   const tokens = getTokens();
   if (!tokens) {
     throw new Error("No tokens found");
@@ -1924,8 +2064,7 @@ function connectToServer2(serverUrl = DEFAULT_SERVER_URL) {
     }
   });
   ws.on("open", () => {
-    console.log(pc4__default.default.green("Connected to server agent streams"));
-    statusEmitter.emit("status", { connected: true });
+    console.log(pc5__default.default.green("Connected to server agent streams"));
   });
   ws.on("message", async (data) => {
     const message = JSON.parse(data.toString());
@@ -1942,34 +2081,33 @@ function connectToServer2(serverUrl = DEFAULT_SERVER_URL) {
           id: message.id,
           result
         }));
-        console.log(pc4__default.default.green(`Tool completed: ${message.tool}`));
+        console.log(pc5__default.default.green(`Tool completed: ${message.tool}`));
       } catch (error) {
         ws.send(JSON.stringify({
           type: "tool_result",
           id: message.id,
           error: error.message
         }));
-        console.error(pc4__default.default.red(`Tool failed: ${message.tool} ${error.message}`));
+        console.error(pc5__default.default.red(`Tool failed: ${message.tool} ${error.message}`));
       }
     }
   });
   ws.on("close", () => {
-    console.log(pc4__default.default.red("Disconnected from server. Reconnecting in 5s..."));
-    statusEmitter.emit("status", { connected: false });
-    setTimeout(() => connectToServer2(serverUrl), 5e3);
+    console.log(pc5__default.default.red("Disconnected from server. Reconnecting in 5s..."));
+    setTimeout(() => connectToServer(serverUrl), 5e3);
   });
   ws.on("error", (error) => {
-    console.error(pc4__default.default.red(`WebSocket error: ${error.message}`));
-    statusEmitter.emit("status", { connected: false });
+    console.error(pc5__default.default.red(`WebSocket error: ${error.message}`));
   });
   return ws;
 }
 async function main() {
   const serverUrl = DEFAULT_SERVER_URL;
-  console.log(pc4__default.default.green("Starting local amai..."));
-  console.log(pc4__default.default.gray(`Connecting to server at ${serverUrl}`));
-  const connection = connectToServer2(serverUrl);
-  startHttpServer(connection);
+  console.log(pc5__default.default.green("Starting local amai..."));
+  console.log(pc5__default.default.gray(`Connecting to server at ${serverUrl}`));
+  connectToServer(serverUrl);
+  await connectToUserStreams(serverUrl);
+  startHttpServer();
 }
 var execAsync2 = util.promisify(child_process.exec);
 var CODE_SERVER_VERSION = "4.96.4";
@@ -1998,44 +2136,44 @@ function getDownloadUrl() {
 }
 function getCodeServerDir() {
   const { platform, arch } = getPlatformInfo();
-  return path9__default.default.join(CODE_DIR, `code-server-${CODE_SERVER_VERSION}-${platform}-${arch}`);
+  return path11__default.default.join(CODE_DIR, `code-server-${CODE_SERVER_VERSION}-${platform}-${arch}`);
 }
 function getCodeServerBin() {
-  return path9__default.default.join(getCodeServerDir(), "bin", "code-server");
+  return path11__default.default.join(getCodeServerDir(), "bin", "code-server");
 }
 function isCodeServerInstalled() {
   const binPath = getCodeServerBin();
-  return fs3__default.default.existsSync(binPath);
+  return fs4__default.default.existsSync(binPath);
 }
 async function installCodeServer() {
   const { ext } = getPlatformInfo();
   const downloadUrl = getDownloadUrl();
-  const tarballPath = path9__default.default.join(AMA_DIR, `code-server.${ext}`);
-  if (!fs3__default.default.existsSync(AMA_DIR)) {
-    fs3__default.default.mkdirSync(AMA_DIR, { recursive: true });
+  const tarballPath = path11__default.default.join(AMA_DIR, `code-server.${ext}`);
+  if (!fs4__default.default.existsSync(AMA_DIR)) {
+    fs4__default.default.mkdirSync(AMA_DIR, { recursive: true });
   }
-  if (!fs3__default.default.existsSync(CODE_DIR)) {
-    fs3__default.default.mkdirSync(CODE_DIR, { recursive: true });
+  if (!fs4__default.default.existsSync(CODE_DIR)) {
+    fs4__default.default.mkdirSync(CODE_DIR, { recursive: true });
   }
-  if (!fs3__default.default.existsSync(STORAGE_DIR)) {
-    fs3__default.default.mkdirSync(STORAGE_DIR, { recursive: true });
+  if (!fs4__default.default.existsSync(STORAGE_DIR)) {
+    fs4__default.default.mkdirSync(STORAGE_DIR, { recursive: true });
   }
-  console.log(pc4__default.default.cyan(`Downloading code-server v${CODE_SERVER_VERSION}...`));
-  console.log(pc4__default.default.gray(downloadUrl));
+  console.log(pc5__default.default.cyan(`Downloading code-server v${CODE_SERVER_VERSION}...`));
+  console.log(pc5__default.default.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__default.default.promises.writeFile(tarballPath, Buffer.from(buffer));
-  console.log(pc4__default.default.cyan("Extracting code-server..."));
+  await fs4__default.default.promises.writeFile(tarballPath, Buffer.from(buffer));
+  console.log(pc5__default.default.cyan("Extracting code-server..."));
   await execAsync2(`tar -xzf ${tarballPath} -C ${CODE_DIR}`);
-  await fs3__default.default.promises.unlink(tarballPath);
+  await fs4__default.default.promises.unlink(tarballPath);
   const binPath = getCodeServerBin();
-  if (fs3__default.default.existsSync(binPath)) {
-    await fs3__default.default.promises.chmod(binPath, 493);
+  if (fs4__default.default.existsSync(binPath)) {
+    await fs4__default.default.promises.chmod(binPath, 493);
   }
-  console.log(pc4__default.default.green("\u2713 code-server installed successfully"));
+  console.log(pc5__default.default.green("\u2713 code-server installed successfully"));
 }
 async function killExistingCodeServer() {
   try {
@@ -2058,23 +2196,23 @@ async function killExistingCodeServer() {
 async function startCodeServer(cwd) {
   const binPath = getCodeServerBin();
   const workDir = cwd || process.cwd();
-  if (!fs3__default.default.existsSync(binPath)) {
+  if (!fs4__default.default.existsSync(binPath)) {
     throw new Error("code-server is not installed. Run installCodeServer() first.");
   }
   await killExistingCodeServer();
-  const workspaceStoragePath = path9__default.default.join(STORAGE_DIR, "User", "workspaceStorage");
-  path9__default.default.join(STORAGE_DIR, "User", "globalStorage");
+  const workspaceStoragePath = path11__default.default.join(STORAGE_DIR, "User", "workspaceStorage");
+  path11__default.default.join(STORAGE_DIR, "User", "globalStorage");
   try {
-    if (fs3__default.default.existsSync(workspaceStoragePath)) {
-      await fs3__default.default.promises.rm(workspaceStoragePath, { recursive: true, force: true });
+    if (fs4__default.default.existsSync(workspaceStoragePath)) {
+      await fs4__default.default.promises.rm(workspaceStoragePath, { recursive: true, force: true });
     }
-    const stateDbPath = path9__default.default.join(STORAGE_DIR, "User", "globalStorage", "state.vscdb");
-    if (fs3__default.default.existsSync(stateDbPath)) {
-      await fs3__default.default.promises.unlink(stateDbPath);
+    const stateDbPath = path11__default.default.join(STORAGE_DIR, "User", "globalStorage", "state.vscdb");
+    if (fs4__default.default.existsSync(stateDbPath)) {
+      await fs4__default.default.promises.unlink(stateDbPath);
     }
   } catch {
   }
-  console.log(pc4__default.default.cyan(`Starting code-server in ${workDir}...`));
+  console.log(pc5__default.default.cyan(`Starting code-server in ${workDir}...`));
   const codeServer = child_process.spawn(
     binPath,
     [
@@ -2093,19 +2231,19 @@ async function startCodeServer(cwd) {
       stdio: ["ignore", "pipe", "pipe"]
     }
   );
-  console.log(pc4__default.default.green(`\u2713 code-server running at http://localhost:8081/?folder=${encodeURIComponent(workDir)}`));
+  console.log(pc5__default.default.green(`\u2713 code-server running at http://localhost:8081/?folder=${encodeURIComponent(workDir)}`));
   return codeServer;
 }
 var __filename$1 = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.cjs', document.baseURI).href)));
-var __dirname$1 = path9.dirname(__filename$1);
-var DAEMON_PID_FILE = path9__default.default.join(AMA_DIR, "daemon.pid");
-var DAEMON_LOG_FILE = path9__default.default.join(AMA_DIR, "daemon.log");
+var __dirname$1 = path11.dirname(__filename$1);
+var DAEMON_PID_FILE = path11__default.default.join(AMA_DIR, "daemon.pid");
+var DAEMON_LOG_FILE = path11__default.default.join(AMA_DIR, "daemon.log");
 function isDaemonRunning() {
-  if (!fs3__default.default.existsSync(DAEMON_PID_FILE)) {
+  if (!fs4__default.default.existsSync(DAEMON_PID_FILE)) {
     return false;
   }
   try {
-    const pid = Number(fs3__default.default.readFileSync(DAEMON_PID_FILE, "utf8"));
+    const pid = Number(fs4__default.default.readFileSync(DAEMON_PID_FILE, "utf8"));
     process.kill(pid, 0);
     return true;
   } catch {
@@ -2113,30 +2251,30 @@ function isDaemonRunning() {
   }
 }
 function stopDaemon() {
-  if (!fs3__default.default.existsSync(DAEMON_PID_FILE)) {
+  if (!fs4__default.default.existsSync(DAEMON_PID_FILE)) {
     return false;
   }
   try {
-    const pid = Number(fs3__default.default.readFileSync(DAEMON_PID_FILE, "utf8"));
+    const pid = Number(fs4__default.default.readFileSync(DAEMON_PID_FILE, "utf8"));
     process.kill(pid, "SIGTERM");
-    fs3__default.default.unlinkSync(DAEMON_PID_FILE);
+    fs4__default.default.unlinkSync(DAEMON_PID_FILE);
     return true;
   } catch (error) {
     return false;
   }
 }
 function startDaemon() {
-  if (!fs3__default.default.existsSync(AMA_DIR)) {
-    fs3__default.default.mkdirSync(AMA_DIR, { recursive: true });
+  if (!fs4__default.default.existsSync(AMA_DIR)) {
+    fs4__default.default.mkdirSync(AMA_DIR, { recursive: true });
   }
   if (isDaemonRunning()) {
     stopDaemon();
   }
-  const daemonScript = path9__default.default.join(__dirname$1, "lib", "daemon-entry.js");
-  if (!fs3__default.default.existsSync(daemonScript)) {
+  const daemonScript = path11__default.default.join(__dirname$1, "lib", "daemon-entry.js");
+  if (!fs4__default.default.existsSync(daemonScript)) {
     throw new Error(`Daemon entry script not found at: ${daemonScript}. Please rebuild the project.`);
   }
-  const logFd = fs3__default.default.openSync(DAEMON_LOG_FILE, "a");
+  const logFd = fs4__default.default.openSync(DAEMON_LOG_FILE, "a");
   const daemon = child_process.spawn(process.execPath, [daemonScript], {
     detached: true,
     stdio: ["ignore", logFd, logFd],
@@ -2144,20 +2282,20 @@ function startDaemon() {
     cwd: process.cwd()
   });
   daemon.unref();
-  fs3__default.default.writeFileSync(DAEMON_PID_FILE, String(daemon.pid));
-  fs3__default.default.closeSync(logFd);
+  fs4__default.default.writeFileSync(DAEMON_PID_FILE, String(daemon.pid));
+  fs4__default.default.closeSync(logFd);
 }
 function getDaemonPid() {
-  if (!fs3__default.default.existsSync(DAEMON_PID_FILE)) {
+  if (!fs4__default.default.existsSync(DAEMON_PID_FILE)) {
     return null;
   }
   try {
-    return Number(fs3__default.default.readFileSync(DAEMON_PID_FILE, "utf8"));
+    return Number(fs4__default.default.readFileSync(DAEMON_PID_FILE, "utf8"));
   } catch {
     return null;
   }
 }
-var VERSION = "0.0.5";
+var VERSION = "0.0.7";
 var PROJECT_DIR = process.cwd();
 function promptUser(question) {
   const rl = readline__default.default.createInterface({
@@ -2173,19 +2311,19 @@ function promptUser(question) {
 }
 async function startWithCodeServer() {
   if (!isCodeServerInstalled()) {
-    console.log(pc4__default.default.cyan("First run detected. Setting up code-server..."));
+    console.log(pc5__default.default.cyan("First run detected. Setting up code-server..."));
     try {
       await installCodeServer();
     } catch (error) {
-      console.error(pc4__default.default.red(`Failed to install code-server: ${error.message}`));
-      console.log(pc4__default.default.yellow("Continuing without code-server..."));
+      console.error(pc5__default.default.red(`Failed to install code-server: ${error.message}`));
+      console.log(pc5__default.default.yellow("Continuing without code-server..."));
     }
   }
   if (isCodeServerInstalled()) {
     try {
       await startCodeServer(PROJECT_DIR);
     } catch (error) {
-      console.error(pc4__default.default.red(`Failed to start code-server: ${error.message}`));
+      console.error(pc5__default.default.red(`Failed to start code-server: ${error.message}`));
     }
   }
   main();
@@ -2193,7 +2331,7 @@ async function startWithCodeServer() {
 var args = process.argv.slice(2);
 if (args[0] === "--help" || args[0] === "-h") {
   console.log(`
-${pc4__default.default.bold("amai cli")} ${pc4__default.default.gray(VERSION)}
+${pc5__default.default.bold("amai cli")} ${pc5__default.default.gray(VERSION)}
 
 Usage: amai [command] [options]
 
@@ -2221,32 +2359,32 @@ Example:
 }
 if (args[0] === "start") {
   if (isDaemonRunning()) {
-    console.log(pc4__default.default.yellow("Daemon is already running"));
+    console.log(pc5__default.default.yellow("Daemon is already running"));
     process.exit(0);
   }
   if (!isAuthenticated()) {
-    console.log(pc4__default.default.yellow("Not authenticated. Please log in first."));
+    console.log(pc5__default.default.yellow("Not authenticated. Please log in first."));
     login().then(() => {
-      console.log(pc4__default.default.green("Starting daemon..."));
+      console.log(pc5__default.default.green("Starting daemon..."));
       startDaemon();
-      console.log(pc4__default.default.green("Daemon started successfully"));
+      console.log(pc5__default.default.green("Daemon started successfully"));
       process.exit(0);
     }).catch(() => {
-      console.error(pc4__default.default.red("Login failed. Cannot start daemon."));
+      console.error(pc5__default.default.red("Login failed. Cannot start daemon."));
       process.exit(1);
     });
   } else {
     startDaemon();
-    console.log(pc4__default.default.green(pc4__default.default.bold("amai started in background mode")));
-    console.log(pc4__default.default.gray(`Tip: You can check status any time with ${pc4__default.default.bold("amai status")}`));
+    console.log(pc5__default.default.green(pc5__default.default.bold("amai started in background mode")));
+    console.log(pc5__default.default.gray(`Tip: You can check status any time with ${pc5__default.default.bold("amai status")}`));
     process.exit(0);
   }
 }
 if (args[0] === "stop") {
   if (stopDaemon()) {
-    console.log(pc4__default.default.green("Daemon stopped successfully"));
+    console.log(pc5__default.default.green("Daemon stopped successfully"));
   } else {
-    console.log(pc4__default.default.yellow("Daemon was not running"));
+    console.log(pc5__default.default.yellow("Daemon was not running"));
   }
   process.exit(0);
 }
@@ -2254,9 +2392,9 @@ if (args[0] === "status") {
   const running = isDaemonRunning();
   const pid = getDaemonPid();
   if (running && pid) {
-    console.log(pc4__default.default.green(`Daemon is running (PID: ${pid})`));
+    console.log(pc5__default.default.green(`Daemon is running (PID: ${pid})`));
   } else {
-    console.log(pc4__default.default.yellow("Daemon is not running"));
+    console.log(pc5__default.default.yellow("Daemon is not running"));
   }
   process.exit(0);
 }
@@ -2264,36 +2402,36 @@ if (args[0] === "project") {
   if (args[1] === "add") {
     const projectPath = args[2];
     if (!projectPath) {
-      console.error(pc4__default.default.red("Please provide a project path"));
+      console.error(pc5__default.default.red("Please provide a project path"));
       console.log("Usage: amai project add <path>");
       process.exit(1);
     }
-    const resolvedPath = path9__default.default.resolve(projectPath);
-    if (!fs3__default.default.existsSync(resolvedPath)) {
-      console.error(pc4__default.default.red(`Path does not exist: ${resolvedPath}`));
+    const resolvedPath = path11__default.default.resolve(projectPath);
+    if (!fs4__default.default.existsSync(resolvedPath)) {
+      console.error(pc5__default.default.red(`Path does not exist: ${resolvedPath}`));
       process.exit(1);
     }
-    if (!fs3__default.default.statSync(resolvedPath).isDirectory()) {
-      console.error(pc4__default.default.red(`Path is not a directory: ${resolvedPath}`));
+    if (!fs4__default.default.statSync(resolvedPath).isDirectory()) {
+      console.error(pc5__default.default.red(`Path is not a directory: ${resolvedPath}`));
       process.exit(1);
     }
-    const projectId = path9__default.default.basename(resolvedPath);
+    const projectId = path11__default.default.basename(resolvedPath);
     projectRegistry.register(projectId, resolvedPath);
-    console.log(pc4__default.default.green(`Project registered: ${projectId} -> ${resolvedPath}`));
+    console.log(pc5__default.default.green(`Project registered: ${projectId} -> ${resolvedPath}`));
     process.exit(0);
   } else if (args[1] === "list") {
     const projects = projectRegistry.list();
     if (projects.length === 0) {
-      console.log(pc4__default.default.yellow("No projects registered"));
+      console.log(pc5__default.default.yellow("No projects registered"));
     } else {
-      console.log(pc4__default.default.bold("Registered projects:"));
+      console.log(pc5__default.default.bold("Registered projects:"));
       projects.forEach((project) => {
-        console.log(`  ${pc4__default.default.cyan(project.id)}: ${project.cwd} ${project.active ? pc4__default.default.green("(active)") : ""}`);
+        console.log(`  ${pc5__default.default.cyan(project.id)}: ${project.cwd} ${project.active ? pc5__default.default.green("(active)") : ""}`);
       });
     }
     process.exit(0);
   } else {
-    console.error(pc4__default.default.red(`Unknown project command: ${args[1]}`));
+    console.error(pc5__default.default.red(`Unknown project command: ${args[1]}`));
     console.log('Use "amai project add <path>" or "amai project list"');
     process.exit(1);
   }
@@ -2302,39 +2440,39 @@ if (args[0] === "login" || args[0] === "--login") {
   login().then(() => process.exit(0)).catch(() => process.exit(1));
 } else if (args[0] === "logout" || args[0] === "--logout") {
   logout();
-  console.log(pc4__default.default.green("Logged out successfully"));
+  console.log(pc5__default.default.green("Logged out successfully"));
   process.exit(0);
 } else {
   (async () => {
     if (!isAuthenticated()) {
-      console.log(pc4__default.default.yellow("Not authenticated. Please log in first."));
+      console.log(pc5__default.default.yellow("Not authenticated. Please log in first."));
       try {
         await login();
       } catch {
-        console.error(pc4__default.default.red("Login failed. Cannot start server."));
+        console.error(pc5__default.default.red("Login failed. Cannot start server."));
         process.exit(1);
       }
     }
     if (isDaemonRunning()) {
-      console.log(pc4__default.default.yellow('Daemon is already running. Use "amai status" to check its status.'));
+      console.log(pc5__default.default.yellow('Daemon is already running. Use "amai status" to check its status.'));
       process.exit(0);
     }
     console.log("");
-    console.log(pc4__default.default.bold("How would you like to run amai?"));
-    console.log(pc4__default.default.gray("Background mode is highly recommended for better performance and stability."));
+    console.log(pc5__default.default.bold("How would you like to run amai?"));
+    console.log(pc5__default.default.gray("Background mode is highly recommended for better performance and stability."));
     const answer = await promptUser(
-      pc4__default.default.cyan("Run in background? (Y/n): ")
+      pc5__default.default.cyan("Run in background? (Y/n): ")
     );
     const runInBackground = answer === "" || answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
     if (runInBackground) {
-      console.log(pc4__default.default.green("Starting daemon in background..."));
+      console.log(pc5__default.default.green("Starting daemon in background..."));
       startDaemon();
-      console.log(pc4__default.default.green("Daemon started successfully!"));
-      console.log(pc4__default.default.gray('Use "amai status" to check daemon status.'));
-      console.log(pc4__default.default.gray('Use "amai stop" to stop the daemon.'));
+      console.log(pc5__default.default.green("Daemon started successfully!"));
+      console.log(pc5__default.default.gray('Use "amai status" to check daemon status.'));
+      console.log(pc5__default.default.gray('Use "amai stop" to stop the daemon.'));
       process.exit(0);
     } else {
-      console.log(pc4__default.default.yellow("Starting in foreground mode..."));
+      console.log(pc5__default.default.yellow("Starting in foreground mode..."));
       startWithCodeServer();
     }
   })();