amai 0.0.8 → 0.0.9

package/dist/lib/daemon-entry.cjs

@@ -5,7 +5,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');
@@ -19,7 +19,7 @@ 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);
 
@@ -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);
@@ -2060,20 +2063,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(pc2__default.default.cyan(`Downloading code-server v${CODE_SERVER_VERSION}...`));
   console.log(pc2__default.default.gray(downloadUrl));
@@ -2082,13 +2085,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(pc2__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"));
 }
@@ -2110,26 +2113,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(pc2__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(pc2__default.default.cyan(`ama installing extension: ${ext}...`));
+      await execAsync3(`"${binPath}" --user-data-dir "${STORAGE_DIR}" --install-extension ${ext}`);
+      console.log(pc2__default.default.green(`ama extension ${ext} installed`));
+    } catch (error) {
+      console.log(pc2__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(pc2__default.default.cyan(`ama starting code-server`));
   const codeServer = child_process.spawn(
     binPath,
     [
@@ -2148,7 +2202,7 @@ 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(pc2__default.default.green(`ama code-server running at http://localhost:8081/?folder=${encodeURIComponent(workDir)}`));
   return codeServer;
 }
 if (process.env.AMA_DAEMON === "1") {