amai 0.0.8 → 0.0.10

package/dist/cli.cjs

@@ -6,7 +6,7 @@ var WebSocket = require('ws');
 var zod = require('zod');
 var fs5 = require('fs/promises');
 var path10 = require('path');
-var fs4 = require('fs');
+var fs6 = require('fs');
 var os3 = require('os');
 var child_process = require('child_process');
 var util = require('util');
@@ -23,7 +23,7 @@ var pc5__default = /*#__PURE__*/_interopDefault(pc5);
 var WebSocket__default = /*#__PURE__*/_interopDefault(WebSocket);
 var fs5__default = /*#__PURE__*/_interopDefault(fs5);
 var path10__default = /*#__PURE__*/_interopDefault(path10);
-var fs4__default = /*#__PURE__*/_interopDefault(fs4);
+var fs6__default = /*#__PURE__*/_interopDefault(fs6);
 var os3__default = /*#__PURE__*/_interopDefault(os3);
 var readline__default = /*#__PURE__*/_interopDefault(readline);
 
@@ -42,14 +42,14 @@ var ProjectRegistry = class {
   }
   load() {
     try {
-      if (fs4__default.default.existsSync(REGISTRY_FILE)) {
-        const data = fs4__default.default.readFileSync(REGISTRY_FILE, "utf8");
+      if (fs6__default.default.existsSync(REGISTRY_FILE)) {
+        const data = fs6__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();
-          fs4__default.default.copyFileSync(REGISTRY_FILE, backupFile);
-          fs4__default.default.unlinkSync(REGISTRY_FILE);
+          fs6__default.default.copyFileSync(REGISTRY_FILE, backupFile);
+          fs6__default.default.unlinkSync(REGISTRY_FILE);
           return;
         }
         const projects = parsed;
@@ -62,11 +62,11 @@ var ProjectRegistry = class {
       }
     } catch (error) {
       console.error("Failed to load project registry:", error);
-      if (fs4__default.default.existsSync(REGISTRY_FILE)) {
+      if (fs6__default.default.existsSync(REGISTRY_FILE)) {
         try {
           const backupFile = REGISTRY_FILE + ".backup." + Date.now();
-          fs4__default.default.copyFileSync(REGISTRY_FILE, backupFile);
-          fs4__default.default.unlinkSync(REGISTRY_FILE);
+          fs6__default.default.copyFileSync(REGISTRY_FILE, backupFile);
+          fs6__default.default.unlinkSync(REGISTRY_FILE);
           console.log("Corrupted registry file backed up and removed. Starting fresh.");
         } catch (backupError) {
         }
@@ -75,11 +75,11 @@ var ProjectRegistry = class {
   }
   save() {
     try {
-      if (!fs4__default.default.existsSync(AMA_DIR)) {
-        fs4__default.default.mkdirSync(AMA_DIR, { recursive: true });
+      if (!fs6__default.default.existsSync(AMA_DIR)) {
+        fs6__default.default.mkdirSync(AMA_DIR, { recursive: true });
       }
       const projects = Array.from(this.projects.values());
-      fs4__default.default.writeFileSync(REGISTRY_FILE, JSON.stringify(projects, null, 2), "utf8");
+      fs6__default.default.writeFileSync(REGISTRY_FILE, JSON.stringify(projects, null, 2), "utf8");
     } catch (error) {
       console.error("Failed to save project registry:", error);
     }
@@ -747,20 +747,20 @@ var editFiles = async function(input, projectCwd) {
     let existingContent = "";
     if (isNewFile === void 0) {
       try {
-        existingContent = await fs4__default.default.promises.readFile(filePath, "utf-8");
+        existingContent = await fs6__default.default.promises.readFile(filePath, "utf-8");
         isNewFile = false;
       } catch (error) {
         isNewFile = true;
       }
     } else if (!isNewFile) {
       try {
-        existingContent = await fs4__default.default.promises.readFile(filePath, "utf-8");
+        existingContent = await fs6__default.default.promises.readFile(filePath, "utf-8");
       } catch (error) {
         isNewFile = true;
       }
     }
     try {
-      await fs4__default.default.promises.writeFile(filePath, content);
+      await fs6__default.default.promises.writeFile(filePath, content);
     } catch (writeError) {
       throw writeError;
     }
@@ -1139,6 +1139,9 @@ var list = async function(input, projectCwd) {
 var startHttpServer = () => {
   const app = new hono.Hono();
   app.use(cors.cors());
+  app.get("/", (c) => {
+    return c.text("Hello World");
+  });
   nodeServer.serve({ fetch: app.fetch, port: 3456 });
 };
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
@@ -1146,10 +1149,10 @@ var CREDENTIALS_DIR = path10__default.default.join(os3__default.default.homedir(
 var CREDENTIALS_PATH = path10__default.default.join(CREDENTIALS_DIR, "credentials.json");
 function isAuthenticated() {
   try {
-    if (!fs4__default.default.existsSync(CREDENTIALS_PATH)) {
+    if (!fs6__default.default.existsSync(CREDENTIALS_PATH)) {
       return false;
     }
-    const raw = fs4__default.default.readFileSync(CREDENTIALS_PATH, "utf8");
+    const raw = fs6__default.default.readFileSync(CREDENTIALS_PATH, "utf8");
     const data = JSON.parse(raw);
     return Boolean(data && data.access_token);
   } catch {
@@ -1158,10 +1161,10 @@ function isAuthenticated() {
 }
 function saveTokens(tokens) {
   try {
-    if (!fs4__default.default.existsSync(CREDENTIALS_DIR)) {
-      fs4__default.default.mkdirSync(CREDENTIALS_DIR, { recursive: true });
+    if (!fs6__default.default.existsSync(CREDENTIALS_DIR)) {
+      fs6__default.default.mkdirSync(CREDENTIALS_DIR, { recursive: true });
     }
-    fs4__default.default.writeFileSync(
+    fs6__default.default.writeFileSync(
       CREDENTIALS_PATH,
       JSON.stringify(tokens, null, 2),
       "utf8"
@@ -1172,18 +1175,18 @@ function saveTokens(tokens) {
 }
 function logout() {
   try {
-    if (fs4__default.default.existsSync(CREDENTIALS_PATH)) {
-      fs4__default.default.unlinkSync(CREDENTIALS_PATH);
+    if (fs6__default.default.existsSync(CREDENTIALS_PATH)) {
+      fs6__default.default.unlinkSync(CREDENTIALS_PATH);
     }
   } catch (error) {
     console.error(pc5__default.default.red("Failed to logout"), error);
   }
 }
 function getTokens() {
-  if (!fs4__default.default.existsSync(CREDENTIALS_PATH)) {
+  if (!fs6__default.default.existsSync(CREDENTIALS_PATH)) {
     return null;
   }
-  const raw = fs4__default.default.readFileSync(CREDENTIALS_PATH, "utf8");
+  const raw = fs6__default.default.readFileSync(CREDENTIALS_PATH, "utf8");
   const data = JSON.parse(raw);
   return data;
 }
@@ -1251,30 +1254,19 @@ async function pollForTokens({
 async function login() {
   try {
     const device = await authorizeDevice();
-    console.log(pc5__default.default.bold("To sign in, follow these steps:"));
+    console.log("");
     if (device.verification_uri_complete) {
-      console.log(
-        `  1. Open this URL in your browser: ${pc5__default.default.cyan(
-          device.verification_uri_complete
-        )}`
-      );
+      console.log(pc5__default.default.cyan(`open: ${device.verification_uri_complete}`));
     } else {
-      console.log(
-        `  1. Open this URL in your browser: ${pc5__default.default.cyan(
-          device.verification_uri
-        )}`
-      );
-      console.log(
-        `  2. Enter this code when prompted: ${pc5__default.default.bold(device.user_code)}`
-      );
+      console.log(pc5__default.default.cyan(`open: ${device.verification_uri}`));
+      console.log(pc5__default.default.gray(`code: ${device.user_code}`));
     }
-    console.log("  3. Come back here; we will detect when you finish logging in.");
-    console.log();
+    console.log("");
     console.log(
       pc5__default.default.gray(
-        `Waiting for authorization (expires in ~${Math.round(
+        `waiting for authorization (~${Math.round(
           device.expires_in / 60
-        )} minutes)...`
+        )} min)...`
       )
     );
     const tokens = await pollForTokens({
@@ -1283,20 +1275,20 @@ async function login() {
       expiresIn: device.expires_in,
       interval: device.interval
     });
-    console.log(pc5__default.default.green("Successfully authenticated!"));
+    console.log(pc5__default.default.cyan("authenticated"));
     saveTokens(tokens);
     return tokens;
   } catch (error) {
-    console.error(pc5__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)) {
+    if (!fs6__default.default.existsSync(CREDENTIALS_PATH)) {
       return;
     }
-    const raw = fs4__default.default.readFileSync(CREDENTIALS_PATH, "utf8");
+    const raw = fs6__default.default.readFileSync(CREDENTIALS_PATH, "utf8");
     const data = JSON.parse(raw);
     return {
       userId: data.user.id
@@ -1443,7 +1435,7 @@ 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 });
+  const filePath = fs6.readdirSync(dir, { withFileTypes: true });
   for (const file of filePath) {
     if (ignoreFiles.includes(file.name)) continue;
     const fullPath = path10__default.default.join(dir, file.name);
@@ -1475,16 +1467,16 @@ function getWorkspaceStoragePath(ide) {
 function scanWorkspaceStorage(ide) {
   const projects = [];
   const storagePath = getWorkspaceStoragePath();
-  if (!fs4__default.default.existsSync(storagePath)) {
+  if (!fs6__default.default.existsSync(storagePath)) {
     return projects;
   }
   try {
-    const workspaces = fs4__default.default.readdirSync(storagePath);
+    const workspaces = fs6__default.default.readdirSync(storagePath);
     for (const workspace of workspaces) {
       const workspaceJsonPath = path10__default.default.join(storagePath, workspace, "workspace.json");
-      if (fs4__default.default.existsSync(workspaceJsonPath)) {
+      if (fs6__default.default.existsSync(workspaceJsonPath)) {
         try {
-          const content = fs4__default.default.readFileSync(workspaceJsonPath, "utf-8");
+          const content = fs6__default.default.readFileSync(workspaceJsonPath, "utf-8");
           const data = JSON.parse(content);
           if (data.folder && typeof data.folder === "string") {
             let projectPath = data.folder;
@@ -1492,7 +1484,7 @@ function scanWorkspaceStorage(ide) {
               projectPath = projectPath.replace("file://", "");
               projectPath = decodeURIComponent(projectPath);
             }
-            if (fs4__default.default.existsSync(projectPath) && fs4__default.default.statSync(projectPath).isDirectory()) {
+            if (fs6__default.default.existsSync(projectPath) && fs6__default.default.statSync(projectPath).isDirectory()) {
               projects.push({
                 name: path10__default.default.basename(projectPath),
                 path: projectPath,
@@ -1516,11 +1508,11 @@ var scanIdeProjects = async () => {
     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 resolvedPath = fs6__default.default.realpathSync(projectPath);
+        if (fs6__default.default.existsSync(resolvedPath) && fs6__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;
+              return fs6__default.default.realpathSync(ideDir) === resolvedPath;
             } catch {
               return false;
             }
@@ -1543,30 +1535,30 @@ var scanIdeProjects = async () => {
     }
     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);
+      if (fs6__default.default.existsSync(dirPath)) {
+        const projects = fs6__default.default.readdirSync(dirPath);
         projects.forEach((project) => {
           const projectPath = path10__default.default.join(dirPath, project);
           try {
-            const stats = fs4__default.default.lstatSync(projectPath);
+            const stats = fs6__default.default.lstatSync(projectPath);
             let actualPath = null;
             if (stats.isSymbolicLink()) {
-              actualPath = fs4__default.default.realpathSync(projectPath);
+              actualPath = fs6__default.default.realpathSync(projectPath);
             } else if (stats.isFile()) {
               try {
-                let content = fs4__default.default.readFileSync(projectPath, "utf-8").trim();
+                let content = fs6__default.default.readFileSync(projectPath, "utf-8").trim();
                 if (content.startsWith("~/") || content === "~") {
                   content = content.replace(/^~/, HOME);
                 }
                 const resolvedContent = path10__default.default.isAbsolute(content) ? content : path10__default.default.resolve(path10__default.default.dirname(projectPath), content);
-                if (fs4__default.default.existsSync(resolvedContent) && fs4__default.default.statSync(resolvedContent).isDirectory()) {
-                  actualPath = fs4__default.default.realpathSync(resolvedContent);
+                if (fs6__default.default.existsSync(resolvedContent) && fs6__default.default.statSync(resolvedContent).isDirectory()) {
+                  actualPath = fs6__default.default.realpathSync(resolvedContent);
                 }
               } catch {
                 return;
               }
             } else if (stats.isDirectory()) {
-              actualPath = fs4__default.default.realpathSync(projectPath);
+              actualPath = fs6__default.default.realpathSync(projectPath);
             }
             if (actualPath) {
               addProject(actualPath, ide);
@@ -1981,7 +1973,19 @@ var rpcHandlers = {
     return { success: true, diff };
   }
 };
+var INITIAL_RECONNECT_DELAY = 1e3;
+var MAX_RECONNECT_DELAY = 6e4;
+var BACKOFF_MULTIPLIER = 2;
 var reconnectTimeout = null;
+var reconnectAttempts = 0;
+function getReconnectDelay() {
+  const delay = Math.min(
+    INITIAL_RECONNECT_DELAY * Math.pow(BACKOFF_MULTIPLIER, reconnectAttempts),
+    MAX_RECONNECT_DELAY
+  );
+  const jitter = delay * 0.25 * (Math.random() * 2 - 1);
+  return Math.floor(delay + jitter);
+}
 var connectToUserStreams = async (serverUrl) => {
   const userId = getUserId();
   if (!userId?.userId) {
@@ -2002,7 +2006,8 @@ var connectToUserStreams = async (serverUrl) => {
     }
   });
   ws.on("open", () => {
-    console.log(pc5__default.default.green("CLI connected to user-streams"));
+    reconnectAttempts = 0;
+    console.log(pc5__default.default.cyan("connected to user streams"));
     if (reconnectTimeout) {
       clearTimeout(reconnectTimeout);
       reconnectTimeout = null;
@@ -2013,7 +2018,7 @@ var connectToUserStreams = async (serverUrl) => {
       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}`));
+        console.log(pc5__default.default.gray(`> ${method}`));
         const handler = rpcHandlers[method];
         if (!handler) {
           ws.send(JSON.stringify({
@@ -2024,7 +2029,6 @@ var connectToUserStreams = async (serverUrl) => {
               message: `Unknown RPC method: ${method}`
             }
           }));
-          console.log(pc5__default.default.yellow(`Unknown RPC method: ${method}`));
           return;
         }
         try {
@@ -2034,7 +2038,6 @@ var connectToUserStreams = async (serverUrl) => {
             requestId,
             data: result
           }));
-          console.log(pc5__default.default.green(`RPC completed: ${method}`));
         } catch (error) {
           const rpcError = error._tag ? error : {
             _tag: "RpcError",
@@ -2045,7 +2048,7 @@ var connectToUserStreams = async (serverUrl) => {
             requestId,
             data: rpcError
           }));
-          console.log(pc5__default.default.red(`RPC failed: ${method} - ${rpcError.message}`));
+          console.log(pc5__default.default.red(`  ${method} failed`));
         }
         return;
       }
@@ -2064,25 +2067,38 @@ var connectToUserStreams = async (serverUrl) => {
         }
       }
     } catch (parseError) {
-      console.error(pc5__default.default.red(`Failed to parse message: ${parseError}`));
+      console.error(pc5__default.default.red(`parse error`));
     }
   });
   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..."));
+    const delay = getReconnectDelay();
+    reconnectAttempts++;
+    console.log(pc5__default.default.gray(`user streams disconnected, reconnecting in ${Math.round(delay / 1e3)}s...`));
     reconnectTimeout = setTimeout(() => {
       connectToUserStreams(serverUrl).catch((err) => {
-        console.error(pc5__default.default.red(`Reconnection failed: ${err.message}`));
+        console.error(pc5__default.default.red(`reconnection failed`));
       });
-    }, 5e3);
+    }, delay);
   });
   ws.on("error", (error) => {
-    console.error(pc5__default.default.red(`User streams WebSocket error: ${error.message}`));
+    console.error(pc5__default.default.red(`stream error: ${error.message}`));
   });
   return ws;
 };
 
 // src/server.ts
+var INITIAL_RECONNECT_DELAY2 = 1e3;
+var MAX_RECONNECT_DELAY2 = 6e4;
+var BACKOFF_MULTIPLIER2 = 2;
+var reconnectAttempts2 = 0;
+function getReconnectDelay2() {
+  const delay = Math.min(
+    INITIAL_RECONNECT_DELAY2 * Math.pow(BACKOFF_MULTIPLIER2, reconnectAttempts2),
+    MAX_RECONNECT_DELAY2
+  );
+  const jitter = delay * 0.25 * (Math.random() * 2 - 1);
+  return Math.floor(delay + jitter);
+}
 var toolExecutors = {
   editFile: editFiles,
   deleteFile,
@@ -2105,12 +2121,13 @@ function connectToServer(serverUrl = DEFAULT_SERVER_URL) {
     }
   });
   ws.on("open", () => {
-    console.log(pc5__default.default.green("Connected to server agent streams"));
+    reconnectAttempts2 = 0;
+    console.log(pc5__default.default.cyan("connected to server"));
   });
   ws.on("message", async (data) => {
     const message = JSON.parse(data.toString());
     if (message.type === "tool_call") {
-      console.log(`tool call: ${message.tool}${message.projectCwd ? ` (project: ${message.projectCwd})` : ""}`);
+      console.log(pc5__default.default.gray(`> ${message.tool}`));
       try {
         const executor = toolExecutors[message.tool];
         if (!executor) {
@@ -2122,17 +2139,16 @@ function connectToServer(serverUrl = DEFAULT_SERVER_URL) {
           id: message.id,
           result
         }));
-        console.log(pc5__default.default.green(`tool call completed: ${message.tool}`));
       } catch (error) {
         ws.send(JSON.stringify({
           type: "tool_result",
           id: message.id,
           error: error.message
         }));
-        console.error(pc5__default.default.red(`tool call failed: ${message.tool} ${error.message}`));
+        console.error(pc5__default.default.red(`  ${message.tool} failed: ${error.message}`));
       }
     } else if (message.type === "rpc_call") {
-      console.log(`rpc call: ${message.method}`);
+      console.log(pc5__default.default.gray(`> rpc: ${message.method}`));
       try {
         const handler = rpcHandlers[message.method];
         if (!handler) {
@@ -2144,29 +2160,30 @@ function connectToServer(serverUrl = DEFAULT_SERVER_URL) {
           id: message.id,
           result
         }));
-        console.log(pc5__default.default.green(`rpc call completed: ${message.method}`));
       } catch (error) {
         ws.send(JSON.stringify({
           type: "tool_result",
           id: message.id,
           error: error.message
         }));
-        console.error(pc5__default.default.red(`rpc call failed: ${message.method} ${error.message}`));
+        console.error(pc5__default.default.red(`  rpc failed: ${message.method}`));
       }
     }
   });
   ws.on("close", () => {
-    console.log(pc5__default.default.red("disconnected from server. reconnecting in 5s..."));
-    setTimeout(() => connectToServer(serverUrl), 5e3);
+    const delay = getReconnectDelay2();
+    reconnectAttempts2++;
+    console.log(pc5__default.default.gray(`disconnected, reconnecting in ${Math.round(delay / 1e3)}s...`));
+    setTimeout(() => connectToServer(serverUrl), delay);
   });
   ws.on("error", (error) => {
-    console.error(pc5__default.default.red(`web socket error: ${error.message}`));
+    console.error(pc5__default.default.red(`connection error: ${error.message}`));
   });
   return ws;
 }
 async function main() {
   const serverUrl = DEFAULT_SERVER_URL;
-  console.log(pc5__default.default.green("starting local amai..."));
+  console.log(pc5__default.default.gray("starting ama..."));
   connectToServer(serverUrl);
   await connectToUserStreams(serverUrl);
   startHttpServer();
@@ -2205,20 +2222,20 @@ function getCodeServerBin() {
 }
 function isCodeServerInstalled() {
   const binPath = getCodeServerBin();
-  return fs4__default.default.existsSync(binPath);
+  return fs6__default.default.existsSync(binPath);
 }
 async function installCodeServer() {
   const { ext } = getPlatformInfo();
   const downloadUrl = getDownloadUrl();
   const tarballPath = path10__default.default.join(AMA_DIR, `code-server.${ext}`);
-  if (!fs4__default.default.existsSync(AMA_DIR)) {
-    fs4__default.default.mkdirSync(AMA_DIR, { recursive: true });
+  if (!fs6__default.default.existsSync(AMA_DIR)) {
+    fs6__default.default.mkdirSync(AMA_DIR, { recursive: true });
   }
-  if (!fs4__default.default.existsSync(CODE_DIR)) {
-    fs4__default.default.mkdirSync(CODE_DIR, { recursive: true });
+  if (!fs6__default.default.existsSync(CODE_DIR)) {
+    fs6__default.default.mkdirSync(CODE_DIR, { recursive: true });
   }
-  if (!fs4__default.default.existsSync(STORAGE_DIR)) {
-    fs4__default.default.mkdirSync(STORAGE_DIR, { recursive: true });
+  if (!fs6__default.default.existsSync(STORAGE_DIR)) {
+    fs6__default.default.mkdirSync(STORAGE_DIR, { recursive: true });
   }
   console.log(pc5__default.default.cyan(`Downloading code-server v${CODE_SERVER_VERSION}...`));
   console.log(pc5__default.default.gray(downloadUrl));
@@ -2227,13 +2244,13 @@ async function installCodeServer() {
     throw new Error(`Failed to download code-server: ${response.statusText}`);
   }
   const buffer = await response.arrayBuffer();
-  await fs4__default.default.promises.writeFile(tarballPath, Buffer.from(buffer));
+  await fs6__default.default.promises.writeFile(tarballPath, Buffer.from(buffer));
   console.log(pc5__default.default.cyan("Extracting code-server..."));
   await execAsync3(`tar -xzf ${tarballPath} -C ${CODE_DIR}`);
-  await fs4__default.default.promises.unlink(tarballPath);
+  await fs6__default.default.promises.unlink(tarballPath);
   const binPath = getCodeServerBin();
-  if (fs4__default.default.existsSync(binPath)) {
-    await fs4__default.default.promises.chmod(binPath, 493);
+  if (fs6__default.default.existsSync(binPath)) {
+    await fs6__default.default.promises.chmod(binPath, 493);
   }
   console.log(pc5__default.default.green("\u2713 code-server installed successfully"));
 }
@@ -2255,26 +2272,77 @@ async function killExistingCodeServer() {
   } catch {
   }
 }
+async function setupDefaultSettings() {
+  const userDir = path10__default.default.join(STORAGE_DIR, "User");
+  const settingsPath = path10__default.default.join(userDir, "settings.json");
+  if (!fs6__default.default.existsSync(userDir)) {
+    fs6__default.default.mkdirSync(userDir, { recursive: true });
+  }
+  const defaultSettings = {
+    // Disable signature verification for Open VSX extensions
+    "extensions.verifySignature": false,
+    // Theme settings
+    "workbench.colorTheme": "Min Dark",
+    "workbench.startupEditor": "none",
+    // Editor settings
+    "editor.fontSize": 14,
+    "editor.fontFamily": "'JetBrains Mono', 'Fira Code', Menlo, Monaco, 'Courier New', monospace",
+    "editor.minimap.enabled": false,
+    "editor.wordWrap": "on",
+    // UI settings
+    "window.menuBarVisibility": "compact",
+    "workbench.activityBar.location": "top"
+  };
+  let existingSettings = {};
+  if (fs6__default.default.existsSync(settingsPath)) {
+    try {
+      const content = await fs6__default.default.promises.readFile(settingsPath, "utf-8");
+      existingSettings = JSON.parse(content);
+    } catch {
+    }
+  }
+  const mergedSettings = { ...defaultSettings, ...existingSettings };
+  mergedSettings["workbench.colorTheme"] = "Min Dark";
+  mergedSettings["extensions.verifySignature"] = false;
+  await fs6__default.default.promises.writeFile(settingsPath, JSON.stringify(mergedSettings, null, 2));
+  console.log(pc5__default.default.green("ama code-server settings configured"));
+}
+async function installExtensions() {
+  const binPath = getCodeServerBin();
+  const extensions = [
+    "castrogusttavo.min-theme"
+  ];
+  for (const ext of extensions) {
+    try {
+      console.log(pc5__default.default.cyan(`ama installing extension: ${ext}...`));
+      await execAsync3(`"${binPath}" --user-data-dir "${STORAGE_DIR}" --install-extension ${ext}`);
+      console.log(pc5__default.default.green(`ama extension ${ext} installed`));
+    } catch (error) {
+      console.log(pc5__default.default.yellow(`ama failed to install extension ${ext}`), error);
+    }
+  }
+}
 async function startCodeServer(cwd) {
   const binPath = getCodeServerBin();
   const workDir = cwd || process.cwd();
-  if (!fs4__default.default.existsSync(binPath)) {
-    throw new Error("code-server is not installed. Run installCodeServer() first.");
+  if (!fs6__default.default.existsSync(binPath)) {
+    throw new Error("ama code-server is not installed. Run installCodeServer() first.");
   }
   await killExistingCodeServer();
+  await setupDefaultSettings();
+  await installExtensions();
   const workspaceStoragePath = path10__default.default.join(STORAGE_DIR, "User", "workspaceStorage");
-  path10__default.default.join(STORAGE_DIR, "User", "globalStorage");
   try {
-    if (fs4__default.default.existsSync(workspaceStoragePath)) {
-      await fs4__default.default.promises.rm(workspaceStoragePath, { recursive: true, force: true });
+    if (fs6__default.default.existsSync(workspaceStoragePath)) {
+      await fs6__default.default.promises.rm(workspaceStoragePath, { recursive: true, force: true });
     }
     const stateDbPath = path10__default.default.join(STORAGE_DIR, "User", "globalStorage", "state.vscdb");
-    if (fs4__default.default.existsSync(stateDbPath)) {
-      await fs4__default.default.promises.unlink(stateDbPath);
+    if (fs6__default.default.existsSync(stateDbPath)) {
+      await fs6__default.default.promises.unlink(stateDbPath);
     }
   } catch {
   }
-  console.log(pc5__default.default.cyan(`Starting code-server in ${workDir}...`));
+  console.log(pc5__default.default.cyan(`ama starting code-server`));
   const codeServer = child_process.spawn(
     binPath,
     [
@@ -2293,7 +2361,7 @@ async function startCodeServer(cwd) {
       stdio: ["ignore", "pipe", "pipe"]
     }
   );
-  console.log(pc5__default.default.green(`\u2713 code-server running at http://localhost:8081/?folder=${encodeURIComponent(workDir)}`));
+  console.log(pc5__default.default.green(`ama 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)));
@@ -2301,11 +2369,11 @@ var __dirname$1 = path10.dirname(__filename$1);
 var DAEMON_PID_FILE = path10__default.default.join(AMA_DIR, "daemon.pid");
 var DAEMON_LOG_FILE = path10__default.default.join(AMA_DIR, "daemon.log");
 function isDaemonRunning() {
-  if (!fs4__default.default.existsSync(DAEMON_PID_FILE)) {
+  if (!fs6__default.default.existsSync(DAEMON_PID_FILE)) {
     return false;
   }
   try {
-    const pid = Number(fs4__default.default.readFileSync(DAEMON_PID_FILE, "utf8"));
+    const pid = Number(fs6__default.default.readFileSync(DAEMON_PID_FILE, "utf8"));
     process.kill(pid, 0);
     return true;
   } catch {
@@ -2313,30 +2381,30 @@ function isDaemonRunning() {
   }
 }
 function stopDaemon() {
-  if (!fs4__default.default.existsSync(DAEMON_PID_FILE)) {
+  if (!fs6__default.default.existsSync(DAEMON_PID_FILE)) {
     return false;
   }
   try {
-    const pid = Number(fs4__default.default.readFileSync(DAEMON_PID_FILE, "utf8"));
+    const pid = Number(fs6__default.default.readFileSync(DAEMON_PID_FILE, "utf8"));
     process.kill(pid, "SIGTERM");
-    fs4__default.default.unlinkSync(DAEMON_PID_FILE);
+    fs6__default.default.unlinkSync(DAEMON_PID_FILE);
     return true;
   } catch (error) {
     return false;
   }
 }
 function startDaemon() {
-  if (!fs4__default.default.existsSync(AMA_DIR)) {
-    fs4__default.default.mkdirSync(AMA_DIR, { recursive: true });
+  if (!fs6__default.default.existsSync(AMA_DIR)) {
+    fs6__default.default.mkdirSync(AMA_DIR, { recursive: true });
   }
   if (isDaemonRunning()) {
     stopDaemon();
   }
   const daemonScript = path10__default.default.join(__dirname$1, "lib", "daemon-entry.js");
-  if (!fs4__default.default.existsSync(daemonScript)) {
+  if (!fs6__default.default.existsSync(daemonScript)) {
     throw new Error(`Daemon entry script not found at: ${daemonScript}. Please rebuild the project.`);
   }
-  const logFd = fs4__default.default.openSync(DAEMON_LOG_FILE, "a");
+  const logFd = fs6__default.default.openSync(DAEMON_LOG_FILE, "a");
   const daemon = child_process.spawn(process.execPath, [daemonScript], {
     detached: true,
     stdio: ["ignore", logFd, logFd],
@@ -2344,21 +2412,27 @@ function startDaemon() {
     cwd: process.cwd()
   });
   daemon.unref();
-  fs4__default.default.writeFileSync(DAEMON_PID_FILE, String(daemon.pid));
-  fs4__default.default.closeSync(logFd);
+  fs6__default.default.writeFileSync(DAEMON_PID_FILE, String(daemon.pid));
+  fs6__default.default.closeSync(logFd);
 }
 function getDaemonPid() {
-  if (!fs4__default.default.existsSync(DAEMON_PID_FILE)) {
+  if (!fs6__default.default.existsSync(DAEMON_PID_FILE)) {
     return null;
   }
   try {
-    return Number(fs4__default.default.readFileSync(DAEMON_PID_FILE, "utf8"));
+    return Number(fs6__default.default.readFileSync(DAEMON_PID_FILE, "utf8"));
   } catch {
     return null;
   }
 }
-var VERSION = "0.0.8";
+var VERSION = "0.0.10";
 var PROJECT_DIR = process.cwd();
+var LOGO = `
+   __ _ _ __ ___   __ _ 
+  / _\` | '_ \` _ \\ / _\` |
+ | (_| | | | | | | (_| |
+  \\__,_|_| |_| |_|\\__,_|
+`;
 function promptUser(question) {
   const rl = readline__default.default.createInterface({
     input: process.stdin,
@@ -2373,168 +2447,249 @@ function promptUser(question) {
 }
 async function startWithCodeServer() {
   if (!isCodeServerInstalled()) {
-    console.log(pc5__default.default.cyan("First run detected. Setting up code-server..."));
+    console.log(pc5__default.default.gray("setting up code-server..."));
     try {
       await installCodeServer();
     } catch (error) {
-      console.error(pc5__default.default.red(`Failed to install code-server: ${error.message}`));
-      console.log(pc5__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.gray("continuing without code-server..."));
     }
   }
   if (isCodeServerInstalled()) {
     try {
       await startCodeServer(PROJECT_DIR);
     } catch (error) {
-      console.error(pc5__default.default.red(`Failed to start code-server: ${error.message}`));
+      console.error(pc5__default.default.red(`failed to start code-server: ${error.message}`));
     }
   }
   main();
 }
+async function checkForUpdates() {
+  try {
+    const response = await fetch("https://registry.npmjs.org/amai/latest");
+    const data = await response.json();
+    const latestVersion = data.version;
+    return {
+      current: VERSION,
+      latest: latestVersion,
+      hasUpdate: latestVersion !== VERSION
+    };
+  } catch {
+    return { current: VERSION, latest: VERSION, hasUpdate: false };
+  }
+}
+function runNpmInstall() {
+  return new Promise((resolve, reject) => {
+    const child = child_process.spawn("npm", ["install", "-g", "amai@latest"], {
+      stdio: "inherit",
+      shell: true
+    });
+    child.on("close", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`npm install exited with code ${code}`));
+    });
+    child.on("error", reject);
+  });
+}
 var args = process.argv.slice(2);
+if (args[0] === "--version" || args[0] === "-v") {
+  console.log(pc5__default.default.gray(`amai ${VERSION}`));
+  process.exit(0);
+}
 if (args[0] === "--help" || args[0] === "-h") {
-  console.log(`
-${pc5__default.default.bold("amai cli")} ${pc5__default.default.gray(VERSION)}
-
-Usage: amai [command] [options]
-
-Commands:
-  login                 Authorize device
-  logout                Log out and remove credentials
-  start                 Start background daemon (background mode is highly recommended for better performance and stability)
-  stop                  Stop background daemon
-  status                Check daemon status
-  project add <path>    Register a project directory
-  project list          List registered projects
-Options:
-  --help, -h            Show this help message
-  --logout, -l          Log out and remove credentials
-Environment Variables:
-  SERVER_URL            Server URL to connect to
-
-Example:
-  amai login
-  amai start
-  amai project add /path/to/project
-  amai                  Start the agent (will prompt for background mode)
-    `);
+  console.log(pc5__default.default.cyan(LOGO));
+  console.log(pc5__default.default.gray(`  v${VERSION}`));
+  console.log("");
+  console.log(pc5__default.default.cyan("  usage"));
+  console.log(pc5__default.default.gray("    amai [command]"));
+  console.log("");
+  console.log(pc5__default.default.cyan("  commands"));
+  console.log(pc5__default.default.gray("    login           authenticate with amai"));
+  console.log(pc5__default.default.gray("    logout          remove credentials"));
+  console.log(pc5__default.default.gray("    start           start background daemon"));
+  console.log(pc5__default.default.gray("    stop            stop background daemon"));
+  console.log(pc5__default.default.gray("    status          check daemon status"));
+  console.log(pc5__default.default.gray("    update          update to latest version"));
+  console.log(pc5__default.default.gray("    project add     register a project"));
+  console.log(pc5__default.default.gray("    project list    list projects"));
+  console.log("");
+  console.log(pc5__default.default.cyan("  options"));
+  console.log(pc5__default.default.gray("    -h, --help      show help"));
+  console.log(pc5__default.default.gray("    -v, --version   show version"));
+  console.log("");
   process.exit(0);
 }
-if (args[0] === "start") {
-  if (isDaemonRunning()) {
-    console.log(pc5__default.default.yellow("ama is already running"));
+if (args[0] === "update") {
+  (async () => {
+    console.log(pc5__default.default.gray("checking for updates..."));
+    const { current, latest, hasUpdate } = await checkForUpdates();
+    if (!hasUpdate) {
+      console.log(pc5__default.default.cyan(`already on latest version (${current})`));
+      process.exit(0);
+    }
+    console.log(pc5__default.default.cyan(`update available: ${current} -> ${latest}`));
+    const answer = await promptUser(pc5__default.default.gray("install update? (Y/n): "));
+    if (answer === "" || answer.toLowerCase() === "y" || answer.toLowerCase() === "yes") {
+      console.log(pc5__default.default.gray("updating..."));
+      try {
+        await runNpmInstall();
+        console.log(pc5__default.default.cyan(`updated to ${latest}`));
+      } catch (error) {
+        console.error(pc5__default.default.red(`update failed: ${error.message}`));
+        process.exit(1);
+      }
+    }
     process.exit(0);
-  }
-  if (!isAuthenticated()) {
-    console.log(pc5__default.default.yellow("Not authenticated. Please log in first."));
-    login().then(() => {
-      console.log(pc5__default.default.green("starting ama in background mode..."));
-      startDaemon();
-      console.log(pc5__default.default.green("ama started in background mode successfully"));
+  })();
+} else if (args[0] === "start") {
+  (async () => {
+    if (isDaemonRunning()) {
+      console.log(pc5__default.default.gray("amai is already running"));
       process.exit(0);
-    }).catch(() => {
-      console.error(pc5__default.default.red("Login failed. Cannot start ama in background mode."));
-      process.exit(1);
-    });
-  } else {
+    }
+    if (!isAuthenticated()) {
+      console.log(pc5__default.default.gray("not authenticated"));
+      try {
+        await login();
+      } catch {
+        console.error(pc5__default.default.red("login failed"));
+        process.exit(1);
+      }
+    }
     startDaemon();
-    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")}`));
+    console.log(pc5__default.default.cyan("amai started"));
+    console.log(pc5__default.default.gray(`check status: amai status`));
     process.exit(0);
-  }
-}
-if (args[0] === "stop") {
+  })();
+} else if (args[0] === "stop") {
   if (stopDaemon()) {
-    console.log(pc5__default.default.green("Daemon stopped successfully"));
+    console.log(pc5__default.default.cyan("daemon stopped"));
   } else {
-    console.log(pc5__default.default.yellow("Daemon was not running"));
+    console.log(pc5__default.default.gray("daemon was not running"));
   }
   process.exit(0);
-}
-if (args[0] === "status") {
+} else if (args[0] === "status") {
   const running = isDaemonRunning();
   const pid = getDaemonPid();
+  console.log("");
+  console.log(pc5__default.default.cyan("  amai status"));
+  console.log("");
   if (running && pid) {
-    console.log(pc5__default.default.green(`Daemon is running (PID: ${pid})`));
+    console.log(pc5__default.default.gray(`  status   running`));
+    console.log(pc5__default.default.gray(`  pid      ${pid}`));
   } else {
-    console.log(pc5__default.default.yellow("Daemon is not running"));
+    console.log(pc5__default.default.gray(`  status   stopped`));
   }
+  console.log(pc5__default.default.gray(`  version  ${VERSION}`));
+  console.log("");
   process.exit(0);
-}
-if (args[0] === "project") {
+} else if (args[0] === "project") {
   if (args[1] === "add") {
     const projectPath = args[2];
     if (!projectPath) {
-      console.error(pc5__default.default.red("Please provide a project path"));
-      console.log("Usage: amai project add <path>");
+      console.error(pc5__default.default.red("please provide a project path"));
+      console.log(pc5__default.default.gray("usage: amai project add <path>"));
       process.exit(1);
     }
     const resolvedPath = path10__default.default.resolve(projectPath);
-    if (!fs4__default.default.existsSync(resolvedPath)) {
-      console.error(pc5__default.default.red(`Path does not exist: ${resolvedPath}`));
+    if (!fs6__default.default.existsSync(resolvedPath)) {
+      console.error(pc5__default.default.red(`path does not exist: ${resolvedPath}`));
       process.exit(1);
     }
-    if (!fs4__default.default.statSync(resolvedPath).isDirectory()) {
-      console.error(pc5__default.default.red(`Path is not a directory: ${resolvedPath}`));
+    if (!fs6__default.default.statSync(resolvedPath).isDirectory()) {
+      console.error(pc5__default.default.red(`path is not a directory: ${resolvedPath}`));
       process.exit(1);
     }
     const projectId = path10__default.default.basename(resolvedPath);
     projectRegistry.register(projectId, resolvedPath);
-    console.log(pc5__default.default.green(`Project registered: ${projectId} -> ${resolvedPath}`));
+    console.log(pc5__default.default.cyan(`project registered: ${projectId}`));
+    console.log(pc5__default.default.gray(`  ${resolvedPath}`));
     process.exit(0);
   } else if (args[1] === "list") {
     const projects = projectRegistry.list();
+    console.log("");
+    console.log(pc5__default.default.cyan("  projects"));
+    console.log("");
     if (projects.length === 0) {
-      console.log(pc5__default.default.yellow("No projects registered"));
+      console.log(pc5__default.default.gray("  no projects registered"));
     } else {
-      console.log(pc5__default.default.bold("Registered projects:"));
       projects.forEach((project) => {
-        console.log(`  ${pc5__default.default.cyan(project.id)}: ${project.cwd} ${project.active ? pc5__default.default.green("(active)") : ""}`);
+        const status = project.active ? pc5__default.default.cyan("active") : pc5__default.default.gray("inactive");
+        console.log(pc5__default.default.gray(`  ${project.id} [${status}]`));
+        console.log(pc5__default.default.gray(`    ${project.cwd}`));
       });
     }
+    console.log("");
     process.exit(0);
   } else {
-    console.error(pc5__default.default.red(`Unknown project command: ${args[1]}`));
-    console.log('Use "amai project add <path>" or "amai project list"');
+    console.error(pc5__default.default.red(`unknown project command: ${args[1]}`));
+    console.log(pc5__default.default.gray("usage: amai project add <path> | amai project list"));
     process.exit(1);
   }
-}
-if (args[0] === "login" || args[0] === "--login") {
-  login().then(() => process.exit(0)).catch(() => process.exit(1));
+} else if (args[0] === "login" || args[0] === "--login") {
+  (async () => {
+    try {
+      await login();
+      console.log("");
+      if (isDaemonRunning()) {
+        console.log(pc5__default.default.gray("amai is already running"));
+        process.exit(0);
+      }
+      const answer = await promptUser(pc5__default.default.gray("start amai now? (Y/n): "));
+      const shouldStart = answer === "" || answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
+      if (shouldStart) {
+        const bgAnswer = await promptUser(pc5__default.default.gray("run in background? (Y/n): "));
+        const runInBackground = bgAnswer === "" || bgAnswer.toLowerCase() === "y" || bgAnswer.toLowerCase() === "yes";
+        if (runInBackground) {
+          console.log(pc5__default.default.gray("starting..."));
+          startDaemon();
+          console.log(pc5__default.default.cyan("amai started"));
+          console.log(pc5__default.default.gray('use "amai status" to check status'));
+        } else {
+          console.log(pc5__default.default.gray("starting in foreground..."));
+          startWithCodeServer();
+          return;
+        }
+      }
+      process.exit(0);
+    } catch {
+      console.error(pc5__default.default.red("login failed"));
+      process.exit(1);
+    }
+  })();
 } else if (args[0] === "logout" || args[0] === "--logout") {
   logout();
-  console.log(pc5__default.default.green("Logged out successfully"));
+  console.log(pc5__default.default.cyan("logged out"));
   process.exit(0);
 } else {
   (async () => {
+    console.log(pc5__default.default.cyan(LOGO));
     if (!isAuthenticated()) {
-      console.log(pc5__default.default.yellow("Not authenticated. Please log in first."));
+      console.log(pc5__default.default.gray("not authenticated"));
       try {
         await login();
+        console.log("");
       } catch {
-        console.error(pc5__default.default.red("Login failed. Cannot start server."));
+        console.error(pc5__default.default.red("login failed"));
         process.exit(1);
       }
     }
     if (isDaemonRunning()) {
-      console.log(pc5__default.default.yellow('Daemon is already running. Use "amai status" to check its status.'));
+      console.log(pc5__default.default.gray("amai is already running"));
+      console.log(pc5__default.default.gray('use "amai status" to check status'));
       process.exit(0);
     }
-    console.log("");
-    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(
-      pc5__default.default.cyan("Run in background? (Y/n): ")
-    );
+    const answer = await promptUser(pc5__default.default.gray("run in background? (Y/n): "));
     const runInBackground = answer === "" || answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
     if (runInBackground) {
-      console.log(pc5__default.default.green("Starting daemon in background..."));
+      console.log(pc5__default.default.gray("starting..."));
       startDaemon();
-      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.'));
+      console.log(pc5__default.default.cyan("amai started"));
+      console.log(pc5__default.default.gray('use "amai status" to check status'));
+      console.log(pc5__default.default.gray('use "amai stop" to stop'));
       process.exit(0);
     } else {
-      console.log(pc5__default.default.yellow("Starting in foreground mode..."));
+      console.log(pc5__default.default.gray("starting in foreground..."));
       startWithCodeServer();
     }
   })();