amai 0.0.8 → 0.0.9

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;
 }
@@ -1293,10 +1296,10 @@ async function login() {
 }
 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 +1446,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 +1478,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 +1495,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 +1519,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 +1546,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);
@@ -2205,20 +2208,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 +2230,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 +2258,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 +2347,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 +2355,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 +2367,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,20 +2398,20 @@ 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.9";
 var PROJECT_DIR = process.cwd();
 function promptUser(question) {
   const rl = readline__default.default.createInterface({
@@ -2469,11 +2523,11 @@ if (args[0] === "project") {
       process.exit(1);
     }
     const resolvedPath = path10__default.default.resolve(projectPath);
-    if (!fs4__default.default.existsSync(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()) {
+    if (!fs6__default.default.statSync(resolvedPath).isDirectory()) {
       console.error(pc5__default.default.red(`Path is not a directory: ${resolvedPath}`));
       process.exit(1);
     }