amai 0.0.8 → 0.0.10

package/dist/lib/daemon-entry.cjs

@@ -5,11 +5,11 @@ 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');
-var pc2 = require('picocolors');
+var pc4 = require('picocolors');
 var hono = require('hono');
 var nodeServer = require('@hono/node-server');
 var cors = require('hono/cors');
@@ -19,9 +19,9 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 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 pc2__default = /*#__PURE__*/_interopDefault(pc2);
+var pc4__default = /*#__PURE__*/_interopDefault(pc4);
 
 var DEFAULT_SERVER_URL = "wss://ama-production-a628.up.railway.app";
 var AMA_DIR = path10__default.default.join(os3__default.default.homedir(), ".amai");
@@ -37,14 +37,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;
@@ -57,11 +57,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) {
         }
@@ -70,11 +70,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);
     }
@@ -742,20 +742,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;
     }
@@ -1134,24 +1134,27 @@ 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 CREDENTIALS_DIR = path10__default.default.join(os3__default.default.homedir(), ".amai");
 var CREDENTIALS_PATH = path10__default.default.join(CREDENTIALS_DIR, "credentials.json");
 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;
 }
 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
@@ -1298,7 +1301,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);
@@ -1330,16 +1333,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;
@@ -1347,7 +1350,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,
@@ -1371,11 +1374,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;
             }
@@ -1398,30 +1401,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);
@@ -1836,7 +1839,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) {
@@ -1857,7 +1872,8 @@ var connectToUserStreams = async (serverUrl) => {
     }
   });
   ws.on("open", () => {
-    console.log(pc2__default.default.green("CLI connected to user-streams"));
+    reconnectAttempts = 0;
+    console.log(pc4__default.default.cyan("connected to user streams"));
     if (reconnectTimeout) {
       clearTimeout(reconnectTimeout);
       reconnectTimeout = null;
@@ -1868,7 +1884,7 @@ var connectToUserStreams = async (serverUrl) => {
       const message = JSON.parse(event.toString());
       if (message._tag === "rpc_call") {
         const { requestId, method, input } = message;
-        console.log(pc2__default.default.gray(`RPC call: ${method}`));
+        console.log(pc4__default.default.gray(`> ${method}`));
         const handler = rpcHandlers[method];
         if (!handler) {
           ws.send(JSON.stringify({
@@ -1879,7 +1895,6 @@ var connectToUserStreams = async (serverUrl) => {
               message: `Unknown RPC method: ${method}`
             }
           }));
-          console.log(pc2__default.default.yellow(`Unknown RPC method: ${method}`));
           return;
         }
         try {
@@ -1889,7 +1904,6 @@ var connectToUserStreams = async (serverUrl) => {
             requestId,
             data: result
           }));
-          console.log(pc2__default.default.green(`RPC completed: ${method}`));
         } catch (error) {
           const rpcError = error._tag ? error : {
             _tag: "RpcError",
@@ -1900,7 +1914,7 @@ var connectToUserStreams = async (serverUrl) => {
             requestId,
             data: rpcError
           }));
-          console.log(pc2__default.default.red(`RPC failed: ${method} - ${rpcError.message}`));
+          console.log(pc4__default.default.red(`  ${method} failed`));
         }
         return;
       }
@@ -1919,25 +1933,38 @@ var connectToUserStreams = async (serverUrl) => {
         }
       }
     } catch (parseError) {
-      console.error(pc2__default.default.red(`Failed to parse message: ${parseError}`));
+      console.error(pc4__default.default.red(`parse error`));
     }
   });
   ws.on("close", (code, reason) => {
-    console.log(pc2__default.default.yellow(`CLI disconnected from user-streams (code: ${code})`));
-    console.log(pc2__default.default.gray("Reconnecting in 5 seconds..."));
+    const delay = getReconnectDelay();
+    reconnectAttempts++;
+    console.log(pc4__default.default.gray(`user streams disconnected, reconnecting in ${Math.round(delay / 1e3)}s...`));
     reconnectTimeout = setTimeout(() => {
       connectToUserStreams(serverUrl).catch((err) => {
-        console.error(pc2__default.default.red(`Reconnection failed: ${err.message}`));
+        console.error(pc4__default.default.red(`reconnection failed`));
       });
-    }, 5e3);
+    }, delay);
   });
   ws.on("error", (error) => {
-    console.error(pc2__default.default.red(`User streams WebSocket error: ${error.message}`));
+    console.error(pc4__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,
@@ -1960,12 +1987,13 @@ function connectToServer(serverUrl = DEFAULT_SERVER_URL) {
     }
   });
   ws.on("open", () => {
-    console.log(pc2__default.default.green("Connected to server agent streams"));
+    reconnectAttempts2 = 0;
+    console.log(pc4__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(pc4__default.default.gray(`> ${message.tool}`));
       try {
         const executor = toolExecutors[message.tool];
         if (!executor) {
@@ -1977,17 +2005,16 @@ function connectToServer(serverUrl = DEFAULT_SERVER_URL) {
           id: message.id,
           result
         }));
-        console.log(pc2__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(pc2__default.default.red(`tool call failed: ${message.tool} ${error.message}`));
+        console.error(pc4__default.default.red(`  ${message.tool} failed: ${error.message}`));
       }
     } else if (message.type === "rpc_call") {
-      console.log(`rpc call: ${message.method}`);
+      console.log(pc4__default.default.gray(`> rpc: ${message.method}`));
       try {
         const handler = rpcHandlers[message.method];
         if (!handler) {
@@ -1999,29 +2026,30 @@ function connectToServer(serverUrl = DEFAULT_SERVER_URL) {
           id: message.id,
           result
         }));
-        console.log(pc2__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(pc2__default.default.red(`rpc call failed: ${message.method} ${error.message}`));
+        console.error(pc4__default.default.red(`  rpc failed: ${message.method}`));
       }
     }
   });
   ws.on("close", () => {
-    console.log(pc2__default.default.red("disconnected from server. reconnecting in 5s..."));
-    setTimeout(() => connectToServer(serverUrl), 5e3);
+    const delay = getReconnectDelay2();
+    reconnectAttempts2++;
+    console.log(pc4__default.default.gray(`disconnected, reconnecting in ${Math.round(delay / 1e3)}s...`));
+    setTimeout(() => connectToServer(serverUrl), delay);
   });
   ws.on("error", (error) => {
-    console.error(pc2__default.default.red(`web socket error: ${error.message}`));
+    console.error(pc4__default.default.red(`connection error: ${error.message}`));
   });
   return ws;
 }
 async function main() {
   const serverUrl = DEFAULT_SERVER_URL;
-  console.log(pc2__default.default.green("starting local amai..."));
+  console.log(pc4__default.default.gray("starting ama..."));
   connectToServer(serverUrl);
   await connectToUserStreams(serverUrl);
   startHttpServer();
@@ -2060,37 +2088,37 @@ 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(pc2__default.default.cyan(`Downloading code-server v${CODE_SERVER_VERSION}...`));
-  console.log(pc2__default.default.gray(downloadUrl));
+  console.log(pc4__default.default.cyan(`Downloading code-server v${CODE_SERVER_VERSION}...`));
+  console.log(pc4__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 fs4__default.default.promises.writeFile(tarballPath, Buffer.from(buffer));
-  console.log(pc2__default.default.cyan("Extracting code-server..."));
+  await fs6__default.default.promises.writeFile(tarballPath, Buffer.from(buffer));
+  console.log(pc4__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(pc2__default.default.green("\u2713 code-server installed successfully"));
+  console.log(pc4__default.default.green("\u2713 code-server installed successfully"));
 }
 async function killExistingCodeServer() {
   try {
@@ -2110,26 +2138,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(pc4__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(pc4__default.default.cyan(`ama installing extension: ${ext}...`));
+      await execAsync3(`"${binPath}" --user-data-dir "${STORAGE_DIR}" --install-extension ${ext}`);
+      console.log(pc4__default.default.green(`ama extension ${ext} installed`));
+    } catch (error) {
+      console.log(pc4__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(pc2__default.default.cyan(`Starting code-server in ${workDir}...`));
+  console.log(pc4__default.default.cyan(`ama starting code-server`));
   const codeServer = child_process.spawn(
     binPath,
     [
@@ -2148,19 +2227,19 @@ async function startCodeServer(cwd) {
       stdio: ["ignore", "pipe", "pipe"]
     }
   );
-  console.log(pc2__default.default.green(`\u2713 code-server running at http://localhost:8081/?folder=${encodeURIComponent(workDir)}`));
+  console.log(pc4__default.default.green(`ama code-server running at http://localhost:8081/?folder=${encodeURIComponent(workDir)}`));
   return codeServer;
 }
 if (process.env.AMA_DAEMON === "1") {
   (async () => {
     try {
       if (!isCodeServerInstalled()) {
-        console.log(pc2__default.default.cyan("First run detected. Setting up code-server..."));
+        console.log(pc4__default.default.gray("setting up code-server..."));
         try {
           await installCodeServer();
         } catch (error) {
-          console.error(pc2__default.default.red(`Failed to install code-server: ${error.message}`));
-          console.log(pc2__default.default.yellow("Continuing without code-server..."));
+          console.error(pc4__default.default.red(`code-server install failed: ${error.message}`));
+          console.log(pc4__default.default.gray("continuing without code-server..."));
         }
       }
       if (isCodeServerInstalled()) {
@@ -2168,16 +2247,16 @@ if (process.env.AMA_DAEMON === "1") {
           const projectDir = process.cwd() || os3__default.default.homedir();
           await startCodeServer(projectDir);
         } catch (error) {
-          console.error(pc2__default.default.red(`Failed to start code-server: ${error.message}`));
+          console.error(pc4__default.default.red(`code-server start failed: ${error.message}`));
         }
       }
       await main();
     } catch (error) {
-      console.error("Daemon error:", error);
+      console.error(pc4__default.default.red("daemon error"));
       process.exit(1);
     }
   })();
 } else {
-  console.error("This script should only be run as a daemon");
+  console.error(pc4__default.default.red("this script should only be run as a daemon"));
   process.exit(1);
 }