amai 0.0.8 → 0.0.10

package/dist/lib/daemon-entry.js

@@ -3,11 +3,11 @@ import WebSocket from 'ws';
 import { z } from 'zod';
 import fs5, { readFile, writeFile, stat, access, readdir, glob, unlink, mkdir } from 'fs/promises';
 import path10 from 'path';
-import fs4, { readdirSync } from 'fs';
+import fs6, { readdirSync } from 'fs';
 import os3 from 'os';
 import { exec, spawn } from 'child_process';
 import { promisify } from 'util';
-import pc2 from 'picocolors';
+import pc4 from 'picocolors';
 import { Hono } from 'hono';
 import { serve } from '@hono/node-server';
 import { cors } from 'hono/cors';
@@ -26,14 +26,14 @@ var ProjectRegistry = class {
   }
   load() {
     try {
-      if (fs4.existsSync(REGISTRY_FILE)) {
-        const data = fs4.readFileSync(REGISTRY_FILE, "utf8");
+      if (fs6.existsSync(REGISTRY_FILE)) {
+        const data = fs6.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.copyFileSync(REGISTRY_FILE, backupFile);
-          fs4.unlinkSync(REGISTRY_FILE);
+          fs6.copyFileSync(REGISTRY_FILE, backupFile);
+          fs6.unlinkSync(REGISTRY_FILE);
           return;
         }
         const projects = parsed;
@@ -46,11 +46,11 @@ var ProjectRegistry = class {
       }
     } catch (error) {
       console.error("Failed to load project registry:", error);
-      if (fs4.existsSync(REGISTRY_FILE)) {
+      if (fs6.existsSync(REGISTRY_FILE)) {
         try {
           const backupFile = REGISTRY_FILE + ".backup." + Date.now();
-          fs4.copyFileSync(REGISTRY_FILE, backupFile);
-          fs4.unlinkSync(REGISTRY_FILE);
+          fs6.copyFileSync(REGISTRY_FILE, backupFile);
+          fs6.unlinkSync(REGISTRY_FILE);
           console.log("Corrupted registry file backed up and removed. Starting fresh.");
         } catch (backupError) {
         }
@@ -59,11 +59,11 @@ var ProjectRegistry = class {
   }
   save() {
     try {
-      if (!fs4.existsSync(AMA_DIR)) {
-        fs4.mkdirSync(AMA_DIR, { recursive: true });
+      if (!fs6.existsSync(AMA_DIR)) {
+        fs6.mkdirSync(AMA_DIR, { recursive: true });
       }
       const projects = Array.from(this.projects.values());
-      fs4.writeFileSync(REGISTRY_FILE, JSON.stringify(projects, null, 2), "utf8");
+      fs6.writeFileSync(REGISTRY_FILE, JSON.stringify(projects, null, 2), "utf8");
     } catch (error) {
       console.error("Failed to save project registry:", error);
     }
@@ -731,20 +731,20 @@ var editFiles = async function(input, projectCwd) {
     let existingContent = "";
     if (isNewFile === void 0) {
       try {
-        existingContent = await fs4.promises.readFile(filePath, "utf-8");
+        existingContent = await fs6.promises.readFile(filePath, "utf-8");
         isNewFile = false;
       } catch (error) {
         isNewFile = true;
       }
     } else if (!isNewFile) {
       try {
-        existingContent = await fs4.promises.readFile(filePath, "utf-8");
+        existingContent = await fs6.promises.readFile(filePath, "utf-8");
       } catch (error) {
         isNewFile = true;
       }
     }
     try {
-      await fs4.promises.writeFile(filePath, content);
+      await fs6.promises.writeFile(filePath, content);
     } catch (writeError) {
       throw writeError;
     }
@@ -1123,24 +1123,27 @@ var list = async function(input, projectCwd) {
 var startHttpServer = () => {
   const app = new Hono();
   app.use(cors());
+  app.get("/", (c) => {
+    return c.text("Hello World");
+  });
   serve({ fetch: app.fetch, port: 3456 });
 };
 var CREDENTIALS_DIR = path10.join(os3.homedir(), ".amai");
 var CREDENTIALS_PATH = path10.join(CREDENTIALS_DIR, "credentials.json");
 function getTokens() {
-  if (!fs4.existsSync(CREDENTIALS_PATH)) {
+  if (!fs6.existsSync(CREDENTIALS_PATH)) {
     return null;
   }
-  const raw = fs4.readFileSync(CREDENTIALS_PATH, "utf8");
+  const raw = fs6.readFileSync(CREDENTIALS_PATH, "utf8");
   const data = JSON.parse(raw);
   return data;
 }
 var getUserId = () => {
   try {
-    if (!fs4.existsSync(CREDENTIALS_PATH)) {
+    if (!fs6.existsSync(CREDENTIALS_PATH)) {
       return;
     }
-    const raw = fs4.readFileSync(CREDENTIALS_PATH, "utf8");
+    const raw = fs6.readFileSync(CREDENTIALS_PATH, "utf8");
     const data = JSON.parse(raw);
     return {
       userId: data.user.id
@@ -1319,16 +1322,16 @@ function getWorkspaceStoragePath(ide) {
 function scanWorkspaceStorage(ide) {
   const projects = [];
   const storagePath = getWorkspaceStoragePath();
-  if (!fs4.existsSync(storagePath)) {
+  if (!fs6.existsSync(storagePath)) {
     return projects;
   }
   try {
-    const workspaces = fs4.readdirSync(storagePath);
+    const workspaces = fs6.readdirSync(storagePath);
     for (const workspace of workspaces) {
       const workspaceJsonPath = path10.join(storagePath, workspace, "workspace.json");
-      if (fs4.existsSync(workspaceJsonPath)) {
+      if (fs6.existsSync(workspaceJsonPath)) {
         try {
-          const content = fs4.readFileSync(workspaceJsonPath, "utf-8");
+          const content = fs6.readFileSync(workspaceJsonPath, "utf-8");
           const data = JSON.parse(content);
           if (data.folder && typeof data.folder === "string") {
             let projectPath = data.folder;
@@ -1336,7 +1339,7 @@ function scanWorkspaceStorage(ide) {
               projectPath = projectPath.replace("file://", "");
               projectPath = decodeURIComponent(projectPath);
             }
-            if (fs4.existsSync(projectPath) && fs4.statSync(projectPath).isDirectory()) {
+            if (fs6.existsSync(projectPath) && fs6.statSync(projectPath).isDirectory()) {
               projects.push({
                 name: path10.basename(projectPath),
                 path: projectPath,
@@ -1360,11 +1363,11 @@ var scanIdeProjects = async () => {
     const seenPaths = /* @__PURE__ */ new Set();
     const addProject = (projectPath, ide) => {
       try {
-        const resolvedPath = fs4.realpathSync(projectPath);
-        if (fs4.existsSync(resolvedPath) && fs4.statSync(resolvedPath).isDirectory() && !seenPaths.has(resolvedPath)) {
+        const resolvedPath = fs6.realpathSync(projectPath);
+        if (fs6.existsSync(resolvedPath) && fs6.statSync(resolvedPath).isDirectory() && !seenPaths.has(resolvedPath)) {
           const isIdeProjectsDir = Object.values(IDE_PROJECTS_PATHS).some((ideDir) => {
             try {
-              return fs4.realpathSync(ideDir) === resolvedPath;
+              return fs6.realpathSync(ideDir) === resolvedPath;
             } catch {
               return false;
             }
@@ -1387,30 +1390,30 @@ var scanIdeProjects = async () => {
     }
     for (const [ide, dirPath] of Object.entries(IDE_PROJECTS_PATHS)) {
       if (ide === "cursor") continue;
-      if (fs4.existsSync(dirPath)) {
-        const projects = fs4.readdirSync(dirPath);
+      if (fs6.existsSync(dirPath)) {
+        const projects = fs6.readdirSync(dirPath);
         projects.forEach((project) => {
           const projectPath = path10.join(dirPath, project);
           try {
-            const stats = fs4.lstatSync(projectPath);
+            const stats = fs6.lstatSync(projectPath);
             let actualPath = null;
             if (stats.isSymbolicLink()) {
-              actualPath = fs4.realpathSync(projectPath);
+              actualPath = fs6.realpathSync(projectPath);
             } else if (stats.isFile()) {
               try {
-                let content = fs4.readFileSync(projectPath, "utf-8").trim();
+                let content = fs6.readFileSync(projectPath, "utf-8").trim();
                 if (content.startsWith("~/") || content === "~") {
                   content = content.replace(/^~/, HOME);
                 }
                 const resolvedContent = path10.isAbsolute(content) ? content : path10.resolve(path10.dirname(projectPath), content);
-                if (fs4.existsSync(resolvedContent) && fs4.statSync(resolvedContent).isDirectory()) {
-                  actualPath = fs4.realpathSync(resolvedContent);
+                if (fs6.existsSync(resolvedContent) && fs6.statSync(resolvedContent).isDirectory()) {
+                  actualPath = fs6.realpathSync(resolvedContent);
                 }
               } catch {
                 return;
               }
             } else if (stats.isDirectory()) {
-              actualPath = fs4.realpathSync(projectPath);
+              actualPath = fs6.realpathSync(projectPath);
             }
             if (actualPath) {
               addProject(actualPath, ide);
@@ -1825,7 +1828,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) {
@@ -1846,7 +1861,8 @@ var connectToUserStreams = async (serverUrl) => {
     }
   });
   ws.on("open", () => {
-    console.log(pc2.green("CLI connected to user-streams"));
+    reconnectAttempts = 0;
+    console.log(pc4.cyan("connected to user streams"));
     if (reconnectTimeout) {
       clearTimeout(reconnectTimeout);
       reconnectTimeout = null;
@@ -1857,7 +1873,7 @@ var connectToUserStreams = async (serverUrl) => {
       const message = JSON.parse(event.toString());
       if (message._tag === "rpc_call") {
         const { requestId, method, input } = message;
-        console.log(pc2.gray(`RPC call: ${method}`));
+        console.log(pc4.gray(`> ${method}`));
         const handler = rpcHandlers[method];
         if (!handler) {
           ws.send(JSON.stringify({
@@ -1868,7 +1884,6 @@ var connectToUserStreams = async (serverUrl) => {
               message: `Unknown RPC method: ${method}`
             }
           }));
-          console.log(pc2.yellow(`Unknown RPC method: ${method}`));
           return;
         }
         try {
@@ -1878,7 +1893,6 @@ var connectToUserStreams = async (serverUrl) => {
             requestId,
             data: result
           }));
-          console.log(pc2.green(`RPC completed: ${method}`));
         } catch (error) {
           const rpcError = error._tag ? error : {
             _tag: "RpcError",
@@ -1889,7 +1903,7 @@ var connectToUserStreams = async (serverUrl) => {
             requestId,
             data: rpcError
           }));
-          console.log(pc2.red(`RPC failed: ${method} - ${rpcError.message}`));
+          console.log(pc4.red(`  ${method} failed`));
         }
         return;
       }
@@ -1908,25 +1922,38 @@ var connectToUserStreams = async (serverUrl) => {
         }
       }
     } catch (parseError) {
-      console.error(pc2.red(`Failed to parse message: ${parseError}`));
+      console.error(pc4.red(`parse error`));
     }
   });
   ws.on("close", (code, reason) => {
-    console.log(pc2.yellow(`CLI disconnected from user-streams (code: ${code})`));
-    console.log(pc2.gray("Reconnecting in 5 seconds..."));
+    const delay = getReconnectDelay();
+    reconnectAttempts++;
+    console.log(pc4.gray(`user streams disconnected, reconnecting in ${Math.round(delay / 1e3)}s...`));
     reconnectTimeout = setTimeout(() => {
       connectToUserStreams(serverUrl).catch((err) => {
-        console.error(pc2.red(`Reconnection failed: ${err.message}`));
+        console.error(pc4.red(`reconnection failed`));
       });
-    }, 5e3);
+    }, delay);
   });
   ws.on("error", (error) => {
-    console.error(pc2.red(`User streams WebSocket error: ${error.message}`));
+    console.error(pc4.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,
@@ -1949,12 +1976,13 @@ function connectToServer(serverUrl = DEFAULT_SERVER_URL) {
     }
   });
   ws.on("open", () => {
-    console.log(pc2.green("Connected to server agent streams"));
+    reconnectAttempts2 = 0;
+    console.log(pc4.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.gray(`> ${message.tool}`));
       try {
         const executor = toolExecutors[message.tool];
         if (!executor) {
@@ -1966,17 +1994,16 @@ function connectToServer(serverUrl = DEFAULT_SERVER_URL) {
           id: message.id,
           result
         }));
-        console.log(pc2.green(`tool call completed: ${message.tool}`));
       } catch (error) {
         ws.send(JSON.stringify({
           type: "tool_result",
           id: message.id,
           error: error.message
         }));
-        console.error(pc2.red(`tool call failed: ${message.tool} ${error.message}`));
+        console.error(pc4.red(`  ${message.tool} failed: ${error.message}`));
       }
     } else if (message.type === "rpc_call") {
-      console.log(`rpc call: ${message.method}`);
+      console.log(pc4.gray(`> rpc: ${message.method}`));
       try {
         const handler = rpcHandlers[message.method];
         if (!handler) {
@@ -1988,29 +2015,30 @@ function connectToServer(serverUrl = DEFAULT_SERVER_URL) {
           id: message.id,
           result
         }));
-        console.log(pc2.green(`rpc call completed: ${message.method}`));
       } catch (error) {
         ws.send(JSON.stringify({
           type: "tool_result",
           id: message.id,
           error: error.message
         }));
-        console.error(pc2.red(`rpc call failed: ${message.method} ${error.message}`));
+        console.error(pc4.red(`  rpc failed: ${message.method}`));
       }
     }
   });
   ws.on("close", () => {
-    console.log(pc2.red("disconnected from server. reconnecting in 5s..."));
-    setTimeout(() => connectToServer(serverUrl), 5e3);
+    const delay = getReconnectDelay2();
+    reconnectAttempts2++;
+    console.log(pc4.gray(`disconnected, reconnecting in ${Math.round(delay / 1e3)}s...`));
+    setTimeout(() => connectToServer(serverUrl), delay);
   });
   ws.on("error", (error) => {
-    console.error(pc2.red(`web socket error: ${error.message}`));
+    console.error(pc4.red(`connection error: ${error.message}`));
   });
   return ws;
 }
 async function main() {
   const serverUrl = DEFAULT_SERVER_URL;
-  console.log(pc2.green("starting local amai..."));
+  console.log(pc4.gray("starting ama..."));
   connectToServer(serverUrl);
   await connectToUserStreams(serverUrl);
   startHttpServer();
@@ -2049,37 +2077,37 @@ function getCodeServerBin() {
 }
 function isCodeServerInstalled() {
   const binPath = getCodeServerBin();
-  return fs4.existsSync(binPath);
+  return fs6.existsSync(binPath);
 }
 async function installCodeServer() {
   const { ext } = getPlatformInfo();
   const downloadUrl = getDownloadUrl();
   const tarballPath = path10.join(AMA_DIR, `code-server.${ext}`);
-  if (!fs4.existsSync(AMA_DIR)) {
-    fs4.mkdirSync(AMA_DIR, { recursive: true });
+  if (!fs6.existsSync(AMA_DIR)) {
+    fs6.mkdirSync(AMA_DIR, { recursive: true });
   }
-  if (!fs4.existsSync(CODE_DIR)) {
-    fs4.mkdirSync(CODE_DIR, { recursive: true });
+  if (!fs6.existsSync(CODE_DIR)) {
+    fs6.mkdirSync(CODE_DIR, { recursive: true });
   }
-  if (!fs4.existsSync(STORAGE_DIR)) {
-    fs4.mkdirSync(STORAGE_DIR, { recursive: true });
+  if (!fs6.existsSync(STORAGE_DIR)) {
+    fs6.mkdirSync(STORAGE_DIR, { recursive: true });
   }
-  console.log(pc2.cyan(`Downloading code-server v${CODE_SERVER_VERSION}...`));
-  console.log(pc2.gray(downloadUrl));
+  console.log(pc4.cyan(`Downloading code-server v${CODE_SERVER_VERSION}...`));
+  console.log(pc4.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.promises.writeFile(tarballPath, Buffer.from(buffer));
-  console.log(pc2.cyan("Extracting code-server..."));
+  await fs6.promises.writeFile(tarballPath, Buffer.from(buffer));
+  console.log(pc4.cyan("Extracting code-server..."));
   await execAsync3(`tar -xzf ${tarballPath} -C ${CODE_DIR}`);
-  await fs4.promises.unlink(tarballPath);
+  await fs6.promises.unlink(tarballPath);
   const binPath = getCodeServerBin();
-  if (fs4.existsSync(binPath)) {
-    await fs4.promises.chmod(binPath, 493);
+  if (fs6.existsSync(binPath)) {
+    await fs6.promises.chmod(binPath, 493);
   }
-  console.log(pc2.green("\u2713 code-server installed successfully"));
+  console.log(pc4.green("\u2713 code-server installed successfully"));
 }
 async function killExistingCodeServer() {
   try {
@@ -2099,26 +2127,77 @@ async function killExistingCodeServer() {
   } catch {
   }
 }
+async function setupDefaultSettings() {
+  const userDir = path10.join(STORAGE_DIR, "User");
+  const settingsPath = path10.join(userDir, "settings.json");
+  if (!fs6.existsSync(userDir)) {
+    fs6.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.existsSync(settingsPath)) {
+    try {
+      const content = await fs6.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.promises.writeFile(settingsPath, JSON.stringify(mergedSettings, null, 2));
+  console.log(pc4.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.cyan(`ama installing extension: ${ext}...`));
+      await execAsync3(`"${binPath}" --user-data-dir "${STORAGE_DIR}" --install-extension ${ext}`);
+      console.log(pc4.green(`ama extension ${ext} installed`));
+    } catch (error) {
+      console.log(pc4.yellow(`ama failed to install extension ${ext}`), error);
+    }
+  }
+}
 async function startCodeServer(cwd) {
   const binPath = getCodeServerBin();
   const workDir = cwd || process.cwd();
-  if (!fs4.existsSync(binPath)) {
-    throw new Error("code-server is not installed. Run installCodeServer() first.");
+  if (!fs6.existsSync(binPath)) {
+    throw new Error("ama code-server is not installed. Run installCodeServer() first.");
   }
   await killExistingCodeServer();
+  await setupDefaultSettings();
+  await installExtensions();
   const workspaceStoragePath = path10.join(STORAGE_DIR, "User", "workspaceStorage");
-  path10.join(STORAGE_DIR, "User", "globalStorage");
   try {
-    if (fs4.existsSync(workspaceStoragePath)) {
-      await fs4.promises.rm(workspaceStoragePath, { recursive: true, force: true });
+    if (fs6.existsSync(workspaceStoragePath)) {
+      await fs6.promises.rm(workspaceStoragePath, { recursive: true, force: true });
     }
     const stateDbPath = path10.join(STORAGE_DIR, "User", "globalStorage", "state.vscdb");
-    if (fs4.existsSync(stateDbPath)) {
-      await fs4.promises.unlink(stateDbPath);
+    if (fs6.existsSync(stateDbPath)) {
+      await fs6.promises.unlink(stateDbPath);
     }
   } catch {
   }
-  console.log(pc2.cyan(`Starting code-server in ${workDir}...`));
+  console.log(pc4.cyan(`ama starting code-server`));
   const codeServer = spawn(
     binPath,
     [
@@ -2137,19 +2216,19 @@ async function startCodeServer(cwd) {
       stdio: ["ignore", "pipe", "pipe"]
     }
   );
-  console.log(pc2.green(`\u2713 code-server running at http://localhost:8081/?folder=${encodeURIComponent(workDir)}`));
+  console.log(pc4.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.cyan("First run detected. Setting up code-server..."));
+        console.log(pc4.gray("setting up code-server..."));
         try {
           await installCodeServer();
         } catch (error) {
-          console.error(pc2.red(`Failed to install code-server: ${error.message}`));
-          console.log(pc2.yellow("Continuing without code-server..."));
+          console.error(pc4.red(`code-server install failed: ${error.message}`));
+          console.log(pc4.gray("continuing without code-server..."));
         }
       }
       if (isCodeServerInstalled()) {
@@ -2157,16 +2236,16 @@ if (process.env.AMA_DAEMON === "1") {
           const projectDir = process.cwd() || os3.homedir();
           await startCodeServer(projectDir);
         } catch (error) {
-          console.error(pc2.red(`Failed to start code-server: ${error.message}`));
+          console.error(pc4.red(`code-server start failed: ${error.message}`));
         }
       }
       await main();
     } catch (error) {
-      console.error("Daemon error:", error);
+      console.error(pc4.red("daemon error"));
       process.exit(1);
     }
   })();
 } else {
-  console.error("This script should only be run as a daemon");
+  console.error(pc4.red("this script should only be run as a daemon"));
   process.exit(1);
 }