@involvex/super-agent-cli 0.0.61 → 0.0.62

package/dist/index.js

@@ -536,11 +536,122 @@ var init_indexer = __esm(() => {
   init_settings_manager();
 });
 
+// src/utils/session-manager.ts
+var exports_session_manager = {};
+__export(exports_session_manager, {
+  getSessionManager: () => getSessionManager,
+  SessionManager: () => SessionManager
+});
+import * as fs13 from "fs-extra";
+import * as path12 from "path";
+
+class SessionManager {
+  static instance;
+  sessionsDir;
+  currentSession = null;
+  constructor() {
+    const settingsManager = getSettingsManager();
+    this.sessionsDir = path12.join(settingsManager.getStorageDirectory(), "sessions");
+    fs13.ensureDirSync(this.sessionsDir);
+  }
+  static getInstance() {
+    if (!SessionManager.instance) {
+      SessionManager.instance = new SessionManager;
+    }
+    return SessionManager.instance;
+  }
+  generateSessionId(workingDir) {
+    const normalized = path12.normalize(workingDir).toLowerCase();
+    return Buffer.from(normalized).toString("base64").replace(/[/+=]/g, "_");
+  }
+  getSessionFilePath(sessionId) {
+    return path12.join(this.sessionsDir, `${sessionId}.json`);
+  }
+  async getOrCreateSession(workingDirectory, name) {
+    const sessionId = this.generateSessionId(workingDirectory);
+    const sessionFile = this.getSessionFilePath(sessionId);
+    try {
+      if (await fs13.pathExists(sessionFile)) {
+        const session = await fs13.readJson(sessionFile);
+        session.lastAccessed = Date.now();
+        this.currentSession = session;
+        await this.saveSession(session);
+        return session;
+      }
+    } catch (error) {}
+    const newSession = {
+      id: sessionId,
+      workingDirectory,
+      name: name || path12.basename(workingDirectory),
+      messages: [],
+      lastAccessed: Date.now(),
+      createdAt: Date.now()
+    };
+    this.currentSession = newSession;
+    await this.saveSession(newSession);
+    return newSession;
+  }
+  async saveSession(session) {
+    const sessionFile = this.getSessionFilePath(session.id);
+    await fs13.outputJson(sessionFile, session, { spaces: 2 });
+  }
+  async addMessage(message) {
+    if (!this.currentSession) {
+      throw new Error("No active session");
+    }
+    this.currentSession.messages.push(message);
+    this.currentSession.lastAccessed = Date.now();
+    await this.saveSession(this.currentSession);
+  }
+  async listSessions() {
+    const sessionFiles = await fs13.readdir(this.sessionsDir);
+    const sessions = [];
+    for (const file of sessionFiles) {
+      if (file.endsWith(".json")) {
+        try {
+          const session = await fs13.readJson(path12.join(this.sessionsDir, file));
+          sessions.push(session);
+        } catch (error) {}
+      }
+    }
+    sessions.sort((a, b) => b.lastAccessed - a.lastAccessed);
+    return sessions;
+  }
+  async deleteSession(sessionId) {
+    const sessionFile = this.getSessionFilePath(sessionId);
+    if (await fs13.pathExists(sessionFile)) {
+      await fs13.remove(sessionFile);
+    }
+  }
+  getCurrentSession() {
+    return this.currentSession;
+  }
+  async switchSession(sessionId) {
+    const sessionFile = this.getSessionFilePath(sessionId);
+    try {
+      if (await fs13.pathExists(sessionFile)) {
+        const session = await fs13.readJson(sessionFile);
+        session.lastAccessed = Date.now();
+        this.currentSession = session;
+        await this.saveSession(session);
+        return session;
+      }
+    } catch (error) {}
+    return null;
+  }
+}
+function getSessionManager() {
+  return SessionManager.getInstance();
+}
+var init_session_manager = __esm(() => {
+  init_settings_manager();
+});
+
 // package.json
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@involvex/super-agent-cli",
-    version: "0.0.61",
+    version: "0.0.62",
     description: "An open-source AI agent that brings the power of Super Agent directly into your terminal.",
     keywords: [
       "cli",
@@ -592,6 +703,7 @@ var require_package = __commonJS((exports, module) => {
     dependencies: {
       "@google/generative-ai": "^0.24.1",
       "@modelcontextprotocol/sdk": "^1.25.3",
+      "@types/mime": "^4.0.0",
       axios: "^1.13.4",
       cfonts: "^3.3.1",
       chalk: "^5.6.2",
@@ -600,7 +712,9 @@ var require_package = __commonJS((exports, module) => {
       dotenv: "^17.2.3",
       enquirer: "^2.4.1",
       "fs-extra": "^11.3.3",
+      ignore: "^7.0.5",
       ink: "^6.6.0",
+      inquirer: "^13.2.2",
       marked: "^17.0.1",
       "marked-terminal": "^7.3.0",
       mime: "^4.1.0",
@@ -638,46 +752,14 @@ var require_package = __commonJS((exports, module) => {
   };
 });
 
-// src/utils/banner.ts
-var exports_banner = {};
-__export(exports_banner, {
-  HELP_BANNER: () => HELP_BANNER,
-  BANNER: () => BANNER
-});
-var BANNER = `
-╔═══════════════════════════════════════════════════════════════╗
-║                                                               ║
-║   ███████╗██╗   ██╗██████╗ ███████╗██████╗                   ║
-║   ██╔════╝██║   ██║██╔══██╗██╔════╝██╔══██╗                  ║
-║   ███████╗██║   ██║██████╔╝█████╗  ██████╔╝                  ║
-║   ╚════██║██║   ██║██╔═══╝ ██╔══╝  ██╔══██╗                  ║
-║   ███████║╚██████╔╝██║     ███████╗██║  ██║                  ║
-║   ╚══════╝ ╚═════╝ ╚═╝     ╚══════╝╚═╝  ╚═╝                  ║
-║                                                               ║
-║    █████╗  ██████╗ ███████╗███╗   ██╗████████╗               ║
-║   ██╔══██╗██╔════╝ ██╔════╝████╗  ██║╚══██╔══╝               ║
-║   ███████║██║  ███╗█████╗  ██╔██╗ ██║   ██║                  ║
-║   ██╔══██║██║   ██║██╔══╝  ██║╚██╗██║   ██║                  ║
-║   ██║  ██║╚██████╔╝███████╗██║ ╚████║   ██║                  ║
-║   ╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝  ╚═══╝   ╚═╝                  ║
-║                                                               ║
-║            \uD83E\uDD16 AI-Powered Terminal Assistant                   ║
-║                                                               ║
-╚═══════════════════════════════════════════════════════════════╝
-`, HELP_BANNER = `
-╔═══════════════════════════════════════════╗
-║      \uD83E\uDD16 SUPER AGENT - Help & Usage       ║
-╚═══════════════════════════════════════════╝
-`;
-
 // src/utils/update-checker.ts
 var exports_update_checker = {};
 __export(exports_update_checker, {
   getUpdateChecker: () => getUpdateChecker,
   UpdateChecker: () => UpdateChecker
 });
-import * as fs13 from "fs-extra";
-import * as path12 from "path";
+import * as fs14 from "fs-extra";
+import * as path13 from "path";
 import axios3 from "axios";
 
 class UpdateChecker {
@@ -686,7 +768,7 @@ class UpdateChecker {
   currentVersion;
   constructor(currentVersion) {
     const settingsManager = getSettingsManager();
-    this.cacheFile = path12.join(settingsManager.getStorageDirectory(), "update-cache.json");
+    this.cacheFile = path13.join(settingsManager.getStorageDirectory(), "update-cache.json");
     this.currentVersion = currentVersion;
   }
   static getInstance(currentVersion) {
@@ -697,8 +779,8 @@ class UpdateChecker {
   }
   async loadCache() {
     try {
-      if (await fs13.pathExists(this.cacheFile)) {
-        const cache = await fs13.readJson(this.cacheFile);
+      if (await fs14.pathExists(this.cacheFile)) {
+        const cache = await fs14.readJson(this.cacheFile);
         const now = Date.now();
         if (cache.lastChecked && now - cache.lastChecked < CACHE_DURATION) {
           return cache;
@@ -709,7 +791,7 @@ class UpdateChecker {
   }
   async saveCache(info) {
     try {
-      await fs13.outputJson(this.cacheFile, info);
+      await fs14.outputJson(this.cacheFile, info);
     } catch (error) {}
   }
   compareVersions(v1, v2) {
@@ -778,459 +860,129 @@ var init_update_checker = __esm(() => {
   CACHE_DURATION = 24 * 60 * 60 * 1000;
 });
 
-// src/utils/session-manager.ts
-var exports_session_manager = {};
-__export(exports_session_manager, {
-  getSessionManager: () => getSessionManager,
-  SessionManager: () => SessionManager
+// src/utils/banner.ts
+var exports_banner = {};
+__export(exports_banner, {
+  HELP_BANNER: () => HELP_BANNER,
+  BANNER: () => BANNER
 });
-import * as fs14 from "fs-extra";
-import * as path13 from "path";
+var BANNER = `
+╔═══════════════════════════════════════════════════════════════╗
+║                                                               ║
+║   ███████╗██╗   ██╗██████╗ ███████╗██████╗                   ║
+║   ██╔════╝██║   ██║██╔══██╗██╔════╝██╔══██╗                  ║
+║   ███████╗██║   ██║██████╔╝█████╗  ██████╔╝                  ║
+║   ╚════██║██║   ██║██╔═══╝ ██╔══╝  ██╔══██╗                  ║
+║   ███████║╚██████╔╝██║     ███████╗██║  ██║                  ║
+║   ╚══════╝ ╚═════╝ ╚═╝     ╚══════╝╚═╝  ╚═╝                  ║
+║                                                               ║
+║    █████╗  ██████╗ ███████╗███╗   ██╗████████╗               ║
+║   ██╔══██╗██╔════╝ ██╔════╝████╗  ██║╚══██╔══╝               ║
+║   ███████║██║  ███╗█████╗  ██╔██╗ ██║   ██║                  ║
+║   ██╔══██║██║   ██║██╔══╝  ██║╚██╗██║   ██║                  ║
+║   ██║  ██║╚██████╔╝███████╗██║ ╚████║   ██║                  ║
+║   ╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝  ╚═══╝   ╚═╝                  ║
+║                                                               ║
+║            \uD83E\uDD16 AI-Powered Terminal Assistant                   ║
+║                                                               ║
+╚═══════════════════════════════════════════════════════════════╝
+`, HELP_BANNER = `
+╔═══════════════════════════════════════════╗
+║      \uD83E\uDD16 SUPER AGENT - Help & Usage       ║
+╚═══════════════════════════════════════════╝
+`;
 
-class SessionManager {
+// src/utils/confirmation-service.ts
+import { EventEmitter } from "events";
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+
+class ConfirmationService extends EventEmitter {
   static instance;
-  sessionsDir;
-  currentSession = null;
-  constructor() {
-    const settingsManager = getSettingsManager();
-    this.sessionsDir = path13.join(settingsManager.getStorageDirectory(), "sessions");
-    fs14.ensureDirSync(this.sessionsDir);
-  }
+  skipConfirmationThisSession = false;
+  pendingConfirmation = null;
+  resolveConfirmation = null;
+  sessionFlags = {
+    fileOperations: false,
+    bashCommands: false,
+    allOperations: false
+  };
   static getInstance() {
-    if (!SessionManager.instance) {
-      SessionManager.instance = new SessionManager;
+    if (!ConfirmationService.instance) {
+      ConfirmationService.instance = new ConfirmationService;
     }
-    return SessionManager.instance;
-  }
-  generateSessionId(workingDir) {
-    const normalized = path13.normalize(workingDir).toLowerCase();
-    return Buffer.from(normalized).toString("base64").replace(/[/+=]/g, "_");
-  }
-  getSessionFilePath(sessionId) {
-    return path13.join(this.sessionsDir, `${sessionId}.json`);
-  }
-  async getOrCreateSession(workingDirectory, name) {
-    const sessionId = this.generateSessionId(workingDirectory);
-    const sessionFile = this.getSessionFilePath(sessionId);
-    try {
-      if (await fs14.pathExists(sessionFile)) {
-        const session = await fs14.readJson(sessionFile);
-        session.lastAccessed = Date.now();
-        this.currentSession = session;
-        await this.saveSession(session);
-        return session;
-      }
-    } catch (error) {}
-    const newSession = {
-      id: sessionId,
-      workingDirectory,
-      name: name || path13.basename(workingDirectory),
-      messages: [],
-      lastAccessed: Date.now(),
-      createdAt: Date.now()
-    };
-    this.currentSession = newSession;
-    await this.saveSession(newSession);
-    return newSession;
+    return ConfirmationService.instance;
   }
-  async saveSession(session) {
-    const sessionFile = this.getSessionFilePath(session.id);
-    await fs14.outputJson(sessionFile, session, { spaces: 2 });
+  constructor() {
+    super();
   }
-  async addMessage(message) {
-    if (!this.currentSession) {
-      throw new Error("No active session");
+  async requestConfirmation(options, operationType = "file") {
+    if (this.sessionFlags.allOperations || operationType === "file" && this.sessionFlags.fileOperations || operationType === "bash" && this.sessionFlags.bashCommands) {
+      return { confirmed: true };
     }
-    this.currentSession.messages.push(message);
-    this.currentSession.lastAccessed = Date.now();
-    await this.saveSession(this.currentSession);
-  }
-  async listSessions() {
-    const sessionFiles = await fs14.readdir(this.sessionsDir);
-    const sessions = [];
-    for (const file of sessionFiles) {
-      if (file.endsWith(".json")) {
-        try {
-          const session = await fs14.readJson(path13.join(this.sessionsDir, file));
-          sessions.push(session);
-        } catch (error) {}
+    if (options.showVSCodeOpen) {
+      try {
+        await this.openInVSCode(options.filename);
+      } catch (error) {
+        options.showVSCodeOpen = false;
       }
     }
-    sessions.sort((a, b) => b.lastAccessed - a.lastAccessed);
-    return sessions;
-  }
-  async deleteSession(sessionId) {
-    const sessionFile = this.getSessionFilePath(sessionId);
-    if (await fs14.pathExists(sessionFile)) {
-      await fs14.remove(sessionFile);
-    }
-  }
-  getCurrentSession() {
-    return this.currentSession;
-  }
-  async switchSession(sessionId) {
-    const sessionFile = this.getSessionFilePath(sessionId);
-    try {
-      if (await fs14.pathExists(sessionFile)) {
-        const session = await fs14.readJson(sessionFile);
-        session.lastAccessed = Date.now();
-        this.currentSession = session;
-        await this.saveSession(session);
-        return session;
-      }
-    } catch (error) {}
-    return null;
-  }
-}
-function getSessionManager() {
-  return SessionManager.getInstance();
-}
-var init_session_manager = __esm(() => {
-  init_settings_manager();
-});
-
-// src/web/server.ts
-var exports_server = {};
-__export(exports_server, {
-  WebServer: () => WebServer
-});
-import { createServer } from "http";
-import { WebSocketServer } from "ws";
-import * as fs15 from "fs-extra";
-import * as path14 from "path";
-import open from "open";
-import mime from "mime";
-
-class WebServer {
-  httpServer;
-  wss;
-  agent;
-  hostname;
-  port;
-  clients = new Set;
-  constructor(options) {
-    this.hostname = options.hostname || "localhost";
-    this.port = options.port || 3000;
-    this.agent = options.agent;
-    this.httpServer = createServer((req, res) => {
-      this.handleHttpRequest(req, res);
+    this.pendingConfirmation = new Promise((resolve) => {
+      this.resolveConfirmation = resolve;
     });
-    this.wss = new WebSocketServer({ server: this.httpServer });
-    this.wss.on("connection", (ws) => {
-      this.handleWebSocketConnection(ws);
+    setImmediate(() => {
+      this.emit("confirmation-requested", options);
     });
-  }
-  async handleHttpRequest(req, res) {
-    const url = req.url || "/";
-    const requestedPath = url === "/" ? "index.html" : url;
-    const sanitizedPath = requestedPath.split("?")[0].split("#")[0];
-    const clientDir = path14.join(__dirname, "../web/client");
-    const absolutePath = path14.resolve(clientDir, sanitizedPath.substring(1));
-    if (!absolutePath.startsWith(clientDir)) {
-      res.writeHead(403, { "Content-Type": "text/plain" });
-      res.end("Forbidden");
-      return;
-    }
-    try {
-      if (await fs15.pathExists(absolutePath)) {
-        const stat5 = await fs15.stat(absolutePath);
-        let filePath = absolutePath;
-        if (stat5.isDirectory()) {
-          filePath = path14.join(absolutePath, "index.html");
-        }
-        const content = await fs15.readFile(filePath);
-        const mimeType = mime.getType(filePath) || "application/octet-stream";
-        res.writeHead(200, { "Content-Type": mimeType });
-        res.end(content);
-      } else {
-        res.writeHead(404);
-        res.end("Not Found");
+    const result = await this.pendingConfirmation;
+    if (result.dontAskAgain) {
+      if (operationType === "file") {
+        this.sessionFlags.fileOperations = true;
+      } else if (operationType === "bash") {
+        this.sessionFlags.bashCommands = true;
       }
-    } catch (error) {
-      console.error("Error serving file:", error);
-      res.writeHead(500);
-      res.end("Internal Server Error");
     }
+    return result;
   }
-  handleWebSocketConnection(ws) {
-    this.clients.add(ws);
-    console.log(`\uD83D\uDCE1 Web client connected (${this.clients.size} total)`);
-    this.checkAndSendUpdateNotification(ws);
-    ws.on("message", async (data) => {
-      try {
-        const message = JSON.parse(data.toString());
-        if (message.type === "prompt") {
-          await this.handlePrompt(message.content, ws);
-        } else if (message.type === "get_file_tree") {
-          await this.handleGetFileTree(ws);
-        } else if (message.type === "get_file_content") {
-          await this.handleGetFileContent(message.path, ws);
-        } else if (message.type === "list_sessions") {
-          await this.handleListSessions(ws);
-        } else if (message.type === "switch_session") {
-          await this.handleSwitchSession(message.sessionId, ws);
-        }
-      } catch (error) {
-        console.error("WebSocket message error:", error);
-        ws.send(JSON.stringify({ type: "error", content: "Invalid message format" }));
-      }
-    });
-    ws.on("close", () => {
-      this.clients.delete(ws);
-      console.log(`\uD83D\uDCE1 Web client disconnected (${this.clients.size} remaining)`);
-    });
-    ws.on("error", (error) => {
-      console.error("WebSocket error:", error);
-    });
+  confirmOperation(confirmed, dontAskAgain) {
+    if (this.resolveConfirmation) {
+      this.resolveConfirmation({ confirmed, dontAskAgain });
+      this.resolveConfirmation = null;
+      this.pendingConfirmation = null;
+    }
   }
-  async handlePrompt(prompt, ws) {
-    try {
-      ws.send(JSON.stringify({ type: "user_message", content: prompt }));
-      const entries = await this.agent.processUserMessage(prompt);
-      for (const entry of entries) {
-        if (entry.type === "assistant") {
-          ws.send(JSON.stringify({
-            type: "assistant_message",
-            content: entry.content
-          }));
-        } else if (entry.type === "tool_call") {
-          ws.send(JSON.stringify({
-            type: "tool_call",
-            tool: entry.toolCall?.function.name,
-            content: "Executing..."
-          }));
-        } else if (entry.type === "tool_result") {
-          ws.send(JSON.stringify({
-            type: "tool_result",
-            tool: entry.toolCall?.function.name,
-            content: entry.content
-          }));
-        }
-      }
-      ws.send(JSON.stringify({ type: "done" }));
-    } catch (error) {
-      ws.send(JSON.stringify({
-        type: "error",
-        content: error.message
-      }));
+  rejectOperation(feedback) {
+    if (this.resolveConfirmation) {
+      this.resolveConfirmation({ confirmed: false, feedback });
+      this.resolveConfirmation = null;
+      this.pendingConfirmation = null;
     }
   }
-  async handleGetFileTree(ws) {
-    try {
-      const { getFileIndexer: getFileIndexer2 } = await Promise.resolve().then(() => (init_indexer(), exports_indexer));
-      const indexer = getFileIndexer2();
-      const index = indexer.getIndex();
-      if (!index) {
-        ws.send(JSON.stringify({ type: "file_tree", tree: [] }));
+  async openInVSCode(filename) {
+    const commands = ["code", "code-insiders", "codium"];
+    for (const cmd of commands) {
+      try {
+        await execAsync(`which ${cmd}`);
+        await execAsync(`${cmd} "${filename}"`);
         return;
+      } catch (error) {
+        continue;
       }
-      const tree = index.entries.filter((e) => !e.path.includes("node_modules") && !e.path.startsWith(".")).map((e) => ({
-        path: e.path,
-        name: path14.basename(e.path),
-        isDirectory: e.isDirectory,
-        size: e.size
-      })).slice(0, 500);
-      ws.send(JSON.stringify({ type: "file_tree", tree }));
-    } catch (error) {
-      ws.send(JSON.stringify({ type: "error", content: error.message }));
     }
+    throw new Error("VS Code not found");
   }
-  async handleGetFileContent(filePath, ws) {
-    try {
-      const fullPath = path14.join(process.cwd(), filePath);
-      if (!fullPath.startsWith(process.cwd())) {
-        throw new Error("Access denied");
-      }
-      const content = await fs15.readFile(fullPath, "utf-8");
-      ws.send(JSON.stringify({
-        type: "file_content",
-        path: filePath,
-        content: content.slice(0, 1e4)
-      }));
-    } catch (error) {
-      ws.send(JSON.stringify({ type: "error", content: error.message }));
-    }
+  isPending() {
+    return this.pendingConfirmation !== null;
   }
-  async handleListSessions(ws) {
-    try {
-      const { getSessionManager: getSessionManager2 } = await Promise.resolve().then(() => (init_session_manager(), exports_session_manager));
-      const sessionManager = getSessionManager2();
-      const sessions = await sessionManager.listSessions();
-      ws.send(JSON.stringify({
-        type: "sessions_list",
-        sessions: sessions.map((s) => ({
-          id: s.id,
-          name: s.name,
-          workingDirectory: s.workingDirectory,
-          messageCount: s.messages.length,
-          lastAccessed: s.lastAccessed
-        }))
-      }));
-    } catch (error) {
-      ws.send(JSON.stringify({ type: "error", content: error.message }));
-    }
+  resetSession() {
+    this.sessionFlags = {
+      fileOperations: false,
+      bashCommands: false,
+      allOperations: false
+    };
   }
-  async handleSwitchSession(sessionId, ws) {
-    try {
-      const { getSessionManager: getSessionManager2 } = await Promise.resolve().then(() => (init_session_manager(), exports_session_manager));
-      const sessionManager = getSessionManager2();
-      const session = await sessionManager.switchSession(sessionId);
-      if (session) {
-        ws.send(JSON.stringify({
-          type: "session_switched",
-          session: {
-            id: session.id,
-            name: session.name,
-            workingDirectory: session.workingDirectory,
-            messages: session.messages
-          }
-        }));
-      } else {
-        throw new Error("Session not found");
-      }
-    } catch (error) {
-      ws.send(JSON.stringify({ type: "error", content: error.message }));
-    }
-  }
-  async checkAndSendUpdateNotification(ws) {
-    try {
-      const pkg = await Promise.resolve().then(() => __toESM(require_package(), 1));
-      const { getUpdateChecker: getUpdateChecker2 } = await Promise.resolve().then(() => (init_update_checker(), exports_update_checker));
-      const updateChecker = getUpdateChecker2(pkg.version);
-      const updateInfo = await updateChecker.checkForUpdates();
-      if (updateInfo?.updateAvailable) {
-        ws.send(JSON.stringify({
-          type: "update_available",
-          currentVersion: updateInfo.currentVersion,
-          latestVersion: updateInfo.latestVersion
-        }));
-      }
-    } catch (error) {}
-  }
-  async start() {
-    return new Promise((resolve5, reject) => {
-      this.httpServer.listen(this.port, this.hostname, () => {
-        const url = `http://${this.hostname}:${this.port}`;
-        console.log(`\uD83C\uDF10 Web interface available at ${url}`);
-        resolve5();
-      });
-      this.httpServer.on("error", (error) => {
-        reject(error);
-      });
-    });
-  }
-  async openBrowser() {
-    const url = `http://${this.hostname}:${this.port}`;
-    try {
-      await open(url);
-      console.log(`\uD83D\uDE80 Opened browser at ${url}`);
-    } catch (error) {
-      console.warn(`Could not open browser automatically. Please visit ${url}`);
-    }
-  }
-  stop() {
-    this.clients.forEach((client) => {
-      client.close();
-    });
-    this.wss.close();
-    this.httpServer.close();
-    console.log("\uD83D\uDED1 Web server stopped");
-  }
-}
-var __dirname = "/home/runner/work/super-agent-cli/super-agent-cli/src/web";
-var init_server = () => {};
-
-// src/utils/confirmation-service.ts
-import { EventEmitter } from "events";
-import { exec } from "child_process";
-import { promisify } from "util";
-var execAsync = promisify(exec);
-
-class ConfirmationService extends EventEmitter {
-  static instance;
-  skipConfirmationThisSession = false;
-  pendingConfirmation = null;
-  resolveConfirmation = null;
-  sessionFlags = {
-    fileOperations: false,
-    bashCommands: false,
-    allOperations: false
-  };
-  static getInstance() {
-    if (!ConfirmationService.instance) {
-      ConfirmationService.instance = new ConfirmationService;
-    }
-    return ConfirmationService.instance;
-  }
-  constructor() {
-    super();
-  }
-  async requestConfirmation(options, operationType = "file") {
-    if (this.sessionFlags.allOperations || operationType === "file" && this.sessionFlags.fileOperations || operationType === "bash" && this.sessionFlags.bashCommands) {
-      return { confirmed: true };
-    }
-    if (options.showVSCodeOpen) {
-      try {
-        await this.openInVSCode(options.filename);
-      } catch (error) {
-        options.showVSCodeOpen = false;
-      }
-    }
-    this.pendingConfirmation = new Promise((resolve) => {
-      this.resolveConfirmation = resolve;
-    });
-    setImmediate(() => {
-      this.emit("confirmation-requested", options);
-    });
-    const result = await this.pendingConfirmation;
-    if (result.dontAskAgain) {
-      if (operationType === "file") {
-        this.sessionFlags.fileOperations = true;
-      } else if (operationType === "bash") {
-        this.sessionFlags.bashCommands = true;
-      }
-    }
-    return result;
-  }
-  confirmOperation(confirmed, dontAskAgain) {
-    if (this.resolveConfirmation) {
-      this.resolveConfirmation({ confirmed, dontAskAgain });
-      this.resolveConfirmation = null;
-      this.pendingConfirmation = null;
-    }
-  }
-  rejectOperation(feedback) {
-    if (this.resolveConfirmation) {
-      this.resolveConfirmation({ confirmed: false, feedback });
-      this.resolveConfirmation = null;
-      this.pendingConfirmation = null;
-    }
-  }
-  async openInVSCode(filename) {
-    const commands = ["code", "code-insiders", "codium"];
-    for (const cmd of commands) {
-      try {
-        await execAsync(`which ${cmd}`);
-        await execAsync(`${cmd} "${filename}"`);
-        return;
-      } catch (error) {
-        continue;
-      }
-    }
-    throw new Error("VS Code not found");
-  }
-  isPending() {
-    return this.pendingConfirmation !== null;
-  }
-  resetSession() {
-    this.sessionFlags = {
-      fileOperations: false,
-      bashCommands: false,
-      allOperations: false
-    };
-  }
-  getSessionFlags() {
-    return { ...this.sessionFlags };
+  getSessionFlags() {
+    return { ...this.sessionFlags };
   }
   setSessionFlag(flagType, value) {
     this.sessionFlags[flagType] = value;
@@ -8416,45 +8168,844 @@ function ChatInterface({
       onApiKeySet: handleApiKeySet
     }, undefined, false, undefined, this);
   }
-  return /* @__PURE__ */ jsxDEV16(ChatInterfaceWithAgent, {
-    agent: currentAgent,
-    initialMessage
-  }, undefined, false, undefined, this);
+  return /* @__PURE__ */ jsxDEV16(ChatInterfaceWithAgent, {
+    agent: currentAgent,
+    initialMessage
+  }, undefined, false, undefined, this);
+}
+
+// src/commands/web.ts
+init_settings_manager();
+
+// src/web/server.ts
+import { createServer } from "http";
+import { WebSocketServer } from "ws";
+import * as fs15 from "fs-extra";
+import * as path14 from "path";
+import open from "open";
+import mime from "mime";
+var __dirname = "/home/runner/work/super-agent-cli/super-agent-cli/src/web";
+
+class WebServer {
+  httpServer;
+  wss;
+  agent;
+  hostname;
+  port;
+  clients = new Set;
+  constructor(options) {
+    this.hostname = options.hostname || "localhost";
+    this.port = options.port || 3000;
+    this.agent = options.agent;
+    this.httpServer = createServer((req, res) => {
+      this.handleHttpRequest(req, res);
+    });
+    this.wss = new WebSocketServer({ server: this.httpServer });
+    this.wss.on("connection", (ws) => {
+      this.handleWebSocketConnection(ws);
+    });
+  }
+  async handleHttpRequest(req, res) {
+    const url = req.url || "/";
+    const requestedPath = url === "/" ? "index.html" : url;
+    const sanitizedPath = requestedPath.split("?")[0].split("#")[0];
+    const clientDir = path14.join(__dirname, "../web/client");
+    const absolutePath = path14.resolve(clientDir, sanitizedPath.substring(1));
+    if (!absolutePath.startsWith(clientDir)) {
+      res.writeHead(403, { "Content-Type": "text/plain" });
+      res.end("Forbidden");
+      return;
+    }
+    try {
+      if (await fs15.pathExists(absolutePath)) {
+        const stat5 = await fs15.stat(absolutePath);
+        let filePath = absolutePath;
+        if (stat5.isDirectory()) {
+          filePath = path14.join(absolutePath, "index.html");
+        }
+        const content = await fs15.readFile(filePath);
+        const mimeType = mime.getType(filePath) || "application/octet-stream";
+        res.writeHead(200, { "Content-Type": mimeType });
+        res.end(content);
+      } else {
+        res.writeHead(404);
+        res.end("Not Found");
+      }
+    } catch (error) {
+      console.error("Error serving file:", error);
+      res.writeHead(500);
+      res.end("Internal Server Error");
+    }
+  }
+  handleWebSocketConnection(ws) {
+    this.clients.add(ws);
+    console.log(`\uD83D\uDCE1 Web client connected (${this.clients.size} total)`);
+    this.checkAndSendUpdateNotification(ws);
+    ws.on("message", async (data) => {
+      try {
+        const message = JSON.parse(data.toString());
+        if (message.type === "prompt") {
+          await this.handlePrompt(message.content, ws);
+        } else if (message.type === "get_file_tree") {
+          await this.handleGetFileTree(ws);
+        } else if (message.type === "get_file_content") {
+          await this.handleGetFileContent(message.path, ws);
+        } else if (message.type === "list_sessions") {
+          await this.handleListSessions(ws);
+        } else if (message.type === "switch_session") {
+          await this.handleSwitchSession(message.sessionId, ws);
+        }
+      } catch (error) {
+        console.error("WebSocket message error:", error);
+        ws.send(JSON.stringify({ type: "error", content: "Invalid message format" }));
+      }
+    });
+    ws.on("close", () => {
+      this.clients.delete(ws);
+      console.log(`\uD83D\uDCE1 Web client disconnected (${this.clients.size} remaining)`);
+    });
+    ws.on("error", (error) => {
+      console.error("WebSocket error:", error);
+    });
+  }
+  async handlePrompt(prompt, ws) {
+    try {
+      ws.send(JSON.stringify({ type: "user_message", content: prompt }));
+      const entries = await this.agent.processUserMessage(prompt);
+      for (const entry of entries) {
+        if (entry.type === "assistant") {
+          ws.send(JSON.stringify({
+            type: "assistant_message",
+            content: entry.content
+          }));
+        } else if (entry.type === "tool_call") {
+          ws.send(JSON.stringify({
+            type: "tool_call",
+            tool: entry.toolCall?.function.name,
+            content: "Executing..."
+          }));
+        } else if (entry.type === "tool_result") {
+          ws.send(JSON.stringify({
+            type: "tool_result",
+            tool: entry.toolCall?.function.name,
+            content: entry.content
+          }));
+        }
+      }
+      ws.send(JSON.stringify({ type: "done" }));
+    } catch (error) {
+      ws.send(JSON.stringify({
+        type: "error",
+        content: error.message
+      }));
+    }
+  }
+  async handleGetFileTree(ws) {
+    try {
+      const { getFileIndexer: getFileIndexer2 } = await Promise.resolve().then(() => (init_indexer(), exports_indexer));
+      const indexer = getFileIndexer2();
+      const index = indexer.getIndex();
+      if (!index) {
+        ws.send(JSON.stringify({ type: "file_tree", tree: [] }));
+        return;
+      }
+      const tree = index.entries.filter((e) => !e.path.includes("node_modules") && !e.path.startsWith(".")).map((e) => ({
+        path: e.path,
+        name: path14.basename(e.path),
+        isDirectory: e.isDirectory,
+        size: e.size
+      })).slice(0, 500);
+      ws.send(JSON.stringify({ type: "file_tree", tree }));
+    } catch (error) {
+      ws.send(JSON.stringify({ type: "error", content: error.message }));
+    }
+  }
+  async handleGetFileContent(filePath, ws) {
+    try {
+      const fullPath = path14.join(process.cwd(), filePath);
+      if (!fullPath.startsWith(process.cwd())) {
+        throw new Error("Access denied");
+      }
+      const content = await fs15.readFile(fullPath, "utf-8");
+      ws.send(JSON.stringify({
+        type: "file_content",
+        path: filePath,
+        content: content.slice(0, 1e4)
+      }));
+    } catch (error) {
+      ws.send(JSON.stringify({ type: "error", content: error.message }));
+    }
+  }
+  async handleListSessions(ws) {
+    try {
+      const { getSessionManager: getSessionManager2 } = await Promise.resolve().then(() => (init_session_manager(), exports_session_manager));
+      const sessionManager = getSessionManager2();
+      const sessions = await sessionManager.listSessions();
+      ws.send(JSON.stringify({
+        type: "sessions_list",
+        sessions: sessions.map((s) => ({
+          id: s.id,
+          name: s.name,
+          workingDirectory: s.workingDirectory,
+          messageCount: s.messages.length,
+          lastAccessed: s.lastAccessed
+        }))
+      }));
+    } catch (error) {
+      ws.send(JSON.stringify({ type: "error", content: error.message }));
+    }
+  }
+  async handleSwitchSession(sessionId, ws) {
+    try {
+      const { getSessionManager: getSessionManager2 } = await Promise.resolve().then(() => (init_session_manager(), exports_session_manager));
+      const sessionManager = getSessionManager2();
+      const session = await sessionManager.switchSession(sessionId);
+      if (session) {
+        ws.send(JSON.stringify({
+          type: "session_switched",
+          session: {
+            id: session.id,
+            name: session.name,
+            workingDirectory: session.workingDirectory,
+            messages: session.messages
+          }
+        }));
+      } else {
+        throw new Error("Session not found");
+      }
+    } catch (error) {
+      ws.send(JSON.stringify({ type: "error", content: error.message }));
+    }
+  }
+  async checkAndSendUpdateNotification(ws) {
+    try {
+      const pkg = await Promise.resolve().then(() => __toESM(require_package(), 1));
+      const { getUpdateChecker: getUpdateChecker2 } = await Promise.resolve().then(() => (init_update_checker(), exports_update_checker));
+      const updateChecker = getUpdateChecker2(pkg.version);
+      const updateInfo = await updateChecker.checkForUpdates();
+      if (updateInfo?.updateAvailable) {
+        ws.send(JSON.stringify({
+          type: "update_available",
+          currentVersion: updateInfo.currentVersion,
+          latestVersion: updateInfo.latestVersion
+        }));
+      }
+    } catch (error) {}
+  }
+  async start() {
+    return new Promise((resolve5, reject) => {
+      this.httpServer.listen(this.port, this.hostname, () => {
+        const url = `http://${this.hostname}:${this.port}`;
+        console.log(`\uD83C\uDF10 Web interface available at ${url}`);
+        resolve5();
+      });
+      this.httpServer.on("error", (error) => {
+        reject(error);
+      });
+    });
+  }
+  async openBrowser() {
+    const url = `http://${this.hostname}:${this.port}`;
+    try {
+      await open(url);
+      console.log(`\uD83D\uDE80 Opened browser at ${url}`);
+    } catch (error) {
+      console.warn(`Could not open browser automatically. Please visit ${url}`);
+    }
+  }
+  stop() {
+    this.clients.forEach((client) => {
+      client.close();
+    });
+    this.wss.close();
+    this.httpServer.close();
+    console.log("\uD83D\uDED1 Web server stopped");
+  }
+}
+
+// src/commands/web.ts
+import { Command } from "commander";
+import chalk from "chalk";
+function createWebCommand() {
+  const webCommand = new Command("web").description("Start the web interface").option("-p, --port <number>", "Port to run server on", "3000").option("--no-browser", "Do not open browser automatically").action(async (options) => {
+    const port = parseInt(options.port);
+    const settingsManager = getSettingsManager();
+    const apiKey = settingsManager.getApiKey();
+    const baseURL = settingsManager.getBaseURL() || "https://api.openai.com/v1";
+    const model = settingsManager.getCurrentModel();
+    if (!apiKey) {
+      console.error(chalk.red("API Key not found. Please configure it first."));
+      process.exit(1);
+    }
+    console.log(chalk.blue(`Starting web server on port ${port}...`));
+    const agent = new SuperAgent(apiKey, baseURL, model);
+    const server = new WebServer({
+      port,
+      agent,
+      openBrowser: options.browser
+    });
+    try {
+      await server.start();
+      if (options.browser) {
+        await server.openBrowser();
+      }
+      process.on("SIGINT", () => {
+        console.log(chalk.yellow(`
+Stopping server...`));
+        server.stop();
+        process.exit(0);
+      });
+    } catch (error) {
+      console.error(chalk.red(`Failed to start server: ${error.message}`));
+      process.exit(1);
+    }
+  });
+  return webCommand;
+}
+function createServeCommand() {
+  const serveCommand = new Command("serve").description("Start the web interface and CLI together").option("-p, --port <number>", "Port to run server on", "3000").action(async (options) => {
+    console.log(chalk.yellow("Serve mode is currently an alias for 'web' mode with background persistence capabilities."));
+    const port = parseInt(options.port);
+    const settingsManager = getSettingsManager();
+    const apiKey = settingsManager.getApiKey();
+    if (!apiKey) {
+      console.error(chalk.red("API Key not found."));
+      process.exit(1);
+    }
+    const agent = new SuperAgent(apiKey, settingsManager.getBaseURL() || "", settingsManager.getCurrentModel());
+    const server = new WebServer({ port, agent, openBrowser: true });
+    await server.start();
+    await server.openBrowser();
+  });
+  return serveCommand;
+}
+
+// src/commands/index-cmd.ts
+import { Command as Command2 } from "commander";
+import fs16 from "fs/promises";
+import ignore from "ignore";
+import chalk2 from "chalk";
+import path15 from "path";
+var DEFAULT_IGNORES = [
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "coverage",
+  ".env",
+  "*.log",
+  ".DS_Store",
+  "Thumbs.db"
+];
+function createIndexCommand() {
+  const indexCommand = new Command2("index").description(" recursively index a directory and save to a file").argument("[directory]", "Directory to index", ".").option("-o, --output <file>", "Output file path (default: index.md)").option("--no-ignore", "Disable .gitignore respecting").option("-d, --depth <depth>", "Max depth to traverse", "10").action(async (directory, options) => {
+    try {
+      const rootDir = path15.resolve(directory);
+      const outputFile2 = options.output ? path15.resolve(options.output) : path15.join(rootDir, "index.md");
+      const maxDepth = parseInt(options.depth);
+      console.log(chalk2.blue(`Indexing directory: ${rootDir}`));
+      const ig = ignore().add(DEFAULT_IGNORES);
+      if (options.ignore !== false) {
+        try {
+          const gitignorePath = path15.join(rootDir, ".gitignore");
+          const gitignoreContent = await fs16.readFile(gitignorePath, "utf-8");
+          ig.add(gitignoreContent);
+        } catch (e) {}
+      }
+      let outputContent = `# Directory Index
+
+Generated for: ${rootDir}
+Date: ${new Date().toISOString()}
+
+`;
+      outputContent += "## File Structure\n\n```\n";
+      async function buildTree(currentPath, depth, prefix = "") {
+        if (depth > maxDepth) {
+          return;
+        }
+        const relativePath = path15.relative(rootDir, currentPath);
+        if (relativePath && ig.ignores(relativePath)) {
+          return;
+        }
+        const stats = await fs16.stat(currentPath);
+        const isDir = stats.isDirectory();
+        const name = path15.basename(currentPath);
+        if (isDir) {
+          if (relativePath) {
+            outputContent += `${prefix}${name}/
+`;
+          }
+          const entries = await fs16.readdir(currentPath, {
+            withFileTypes: true
+          });
+          const sortedEntries = entries.sort((a, b) => {
+            if (a.isDirectory() && !b.isDirectory()) {
+              return -1;
+            }
+            if (!a.isDirectory() && b.isDirectory()) {
+              return 1;
+            }
+            return a.name.localeCompare(b.name);
+          });
+          for (let i = 0;i < sortedEntries.length; i++) {
+            const entry = sortedEntries[i];
+            const isLast = i === sortedEntries.length - 1;
+            const newPrefix = relativePath ? prefix + "  " : "";
+            await buildTree(path15.join(currentPath, entry.name), depth + 1, newPrefix);
+          }
+        } else {
+          outputContent += `${prefix}${name}
+`;
+        }
+      }
+      const files = [];
+      async function walk(dir, currentDepth) {
+        if (currentDepth > maxDepth) {
+          return;
+        }
+        const entries = await fs16.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          const fullPath = path15.join(dir, entry.name);
+          const relPath = path15.relative(rootDir, fullPath);
+          if (ig.ignores(relPath)) {
+            continue;
+          }
+          if (entry.isDirectory()) {
+            await walk(fullPath, currentDepth + 1);
+          } else {
+            files.push(relPath);
+          }
+        }
+      }
+      await walk(rootDir, 0);
+      console.log(chalk2.blue(`Found ${files.length} files.`));
+      outputContent = `# Project Index: ${path15.basename(rootDir)}
+
+`;
+      outputContent += `Total Files: ${files.length}
+
+`;
+      outputContent += `## Files
+
+`;
+      for (const file of files) {
+        outputContent += `### ${file}
+`;
+        const stats = await fs16.stat(path15.join(rootDir, file));
+        outputContent += `- Size: ${stats.size} bytes
+`;
+        outputContent += `- Modified: ${stats.mtime.toISOString()}
+
+`;
+      }
+      await fs16.writeFile(outputFile2, outputContent);
+      console.log(chalk2.green(`✓ Index generated at: ${outputFile2}`));
+    } catch (error) {
+      console.error(chalk2.red(`Error indexing directory: ${error.message}`));
+      process.exit(1);
+    }
+  });
+  return indexCommand;
+}
+
+// src/commands/plugins.ts
+init_settings_manager();
+import { Command as Command3 } from "commander";
+function createPluginsCommand() {
+  const pluginsCommand = new Command3("plugins").description("Manage plugins for Super Agent CLI").argument("[action]", "Action to perform (list, install, uninstall)").argument("[target]", "Plugin name or path");
+  pluginsCommand.command("list").description("List installed plugins").action(() => {
+    const manager = getSettingsManager();
+    const settings = manager.loadUserSettings();
+    const plugins = settings.plugins || [];
+    if (plugins.length === 0) {
+      console.log("No plugins installed.");
+      return;
+    }
+    console.log("Installed plugins:");
+    plugins.forEach((p) => console.log(`- ${p}`));
+  });
+  pluginsCommand.command("install <path>").description("Install a plugin from a path, GitHub URL, or registry").action(async (path16) => {
+    try {
+      const manager = PluginManager.getInstance();
+      console.log(`Installing plugin from: ${path16}...`);
+      const installedPath = await manager.installPlugin(path16);
+      console.log(`✅ Plugin installed successfully: ${installedPath}`);
+    } catch (error) {
+      console.error(`❌ Error installing plugin: ${error.message}`);
+      process.exit(1);
+    }
+  });
+  pluginsCommand.command("uninstall <path>").description("Uninstall a plugin").action(async (path16) => {
+    try {
+      const manager = PluginManager.getInstance();
+      await manager.removePlugin(path16);
+      console.log(`✅ Plugin uninstalled: ${path16}`);
+    } catch (error) {
+      console.error(`❌ Error uninstalling plugin: ${error.message}`);
+      process.exit(1);
+    }
+  });
+  return pluginsCommand;
+}
+
+// src/commands/skills.ts
+init_settings_manager();
+
+// src/skills/manager.ts
+init_settings_manager();
+import fs17 from "fs/promises";
+import path16 from "path";
+
+class SkillsManager {
+  static instance;
+  skillsPath;
+  constructor() {
+    this.skillsPath = path16.join(getSettingsManager().getStorageDirectory(), "skills");
+  }
+  static getInstance() {
+    if (!SkillsManager.instance) {
+      SkillsManager.instance = new SkillsManager;
+    }
+    return SkillsManager.instance;
+  }
+  async ensureSkillsDirectory() {
+    try {
+      await fs17.mkdir(this.skillsPath, { recursive: true });
+    } catch (error) {}
+  }
+  async listSkills() {
+    await this.ensureSkillsDirectory();
+    try {
+      const files = await fs17.readdir(this.skillsPath);
+      return files.filter((file) => file.endsWith(".ts") || file.endsWith(".js") || file.endsWith(".json")).map((file) => path16.parse(file).name);
+    } catch (error) {
+      return [];
+    }
+  }
+  async getSkillPath(name) {
+    const extensions = [".ts", ".js", ".json"];
+    for (const ext of extensions) {
+      const fullPath = path16.join(this.skillsPath, `${name}${ext}`);
+      try {
+        await fs17.access(fullPath);
+        return fullPath;
+      } catch {
+        continue;
+      }
+    }
+    throw new Error(`Skill '${name}' not found`);
+  }
+  async getSkillContent(name) {
+    const skillPath = await this.getSkillPath(name);
+    return await fs17.readFile(skillPath, "utf-8");
+  }
+  async createSkill(name, description, agent) {
+    await this.ensureSkillsDirectory();
+    const prompt = `Create a robust TypeScript skill for the Super Agent CLI named "${name}".
+    
+    Description: ${description}
+    
+    The skill should be a module that exports a default function or class that implements the desired functionality.
+    It should valid standalone TypeScript code.
+    Include comments explaining how it works.
+    
+    Structure:
+    \`\`\`typescript
+    // ${name} skill
+    export default async function(args: any) {
+      // implementation
+    }
+    \`\`\`
+    
+    Return ONLY the code block.`;
+    const response = await agent.processUserMessage(prompt);
+    let code = "";
+    for (const entry of response) {
+      if (entry.type === "assistant") {
+        const match = entry.content.match(/```(?:typescript|ts)?\n([\s\S]*?)```/);
+        if (match) {
+          code = match[1];
+          break;
+        } else {
+          code = entry.content;
+        }
+      }
+    }
+    if (!code) {
+      throw new Error("Failed to generate skill code");
+    }
+    const filePath = path16.join(this.skillsPath, `${name}.ts`);
+    await fs17.writeFile(filePath, code);
+  }
+  async deleteSkill(name) {
+    try {
+      const skillPath = await this.getSkillPath(name);
+      await fs17.unlink(skillPath);
+    } catch (error) {
+      throw new Error(`Failed to delete skill '${name}': ${error.message}`);
+    }
+  }
+}
+
+// src/commands/skills.ts
+import { Command as Command4 } from "commander";
+import inquirer from "inquirer";
+import chalk3 from "chalk";
+function createSkillsCommand() {
+  const skillsCommand = new Command4("skills").description("Manage AI skills");
+  skillsCommand.command("list").description("List available skills").action(async () => {
+    const manager = SkillsManager.getInstance();
+    const skills = await manager.listSkills();
+    if (skills.length === 0) {
+      console.log("No skills found.");
+    } else {
+      console.log("Available skills:");
+      skills.forEach((skill) => console.log(`- ${skill}`));
+    }
+  });
+  skillsCommand.command("create <name>").description("Create a new skill with AI assistance").option("-d, --description <description>", "Description of the skill").action(async (name, options) => {
+    try {
+      const manager = SkillsManager.getInstance();
+      const settingsManager = getSettingsManager();
+      let description = options.description;
+      if (!description) {
+        const answer = await inquirer.prompt([
+          {
+            type: "input",
+            name: "description",
+            message: "Describe what this skill should do:"
+          }
+        ]);
+        description = answer.description;
+      }
+      console.log(chalk3.blue(`Generating skill '${name}' based on description: "${description}"...`));
+      const apiKey = settingsManager.getApiKey();
+      const baseURL = settingsManager.getBaseURL();
+      const model = settingsManager.getCurrentModel();
+      if (!apiKey) {
+        console.error(chalk3.red("API Key not found. Please configure it first."));
+        return;
+      }
+      const agent = new SuperAgent(apiKey, baseURL, model);
+      await manager.createSkill(name, description, agent);
+      console.log(chalk3.green(`✓ Skill '${name}' created successfully.`));
+    } catch (error) {
+      console.error(chalk3.red(`Error creating skill: ${error.message}`));
+    }
+  });
+  skillsCommand.command("delete <name>").description("Delete a skill").action(async (name) => {
+    try {
+      const manager = SkillsManager.getInstance();
+      await manager.deleteSkill(name);
+      console.log(chalk3.green(`✓ Skill '${name}' deleted.`));
+    } catch (error) {
+      console.error(chalk3.red(`Error deleting skill: ${error.message}`));
+    }
+  });
+  return skillsCommand;
+}
+
+// src/commands/agents.ts
+init_settings_manager();
+
+// src/agents/manager.ts
+init_settings_manager();
+import fs18 from "fs/promises";
+import path17 from "path";
+
+class AgentsManager {
+  static instance;
+  agentsPath;
+  constructor() {
+    this.agentsPath = path17.join(getSettingsManager().getStorageDirectory(), "agents");
+  }
+  static getInstance() {
+    if (!AgentsManager.instance) {
+      AgentsManager.instance = new AgentsManager;
+    }
+    return AgentsManager.instance;
+  }
+  async ensureAgentsDirectory() {
+    try {
+      await fs18.mkdir(this.agentsPath, { recursive: true });
+    } catch (error) {}
+  }
+  async listAgents() {
+    await this.ensureAgentsDirectory();
+    try {
+      const files = await fs18.readdir(this.agentsPath);
+      const agents = [];
+      for (const file of files) {
+        if (file.endsWith(".json")) {
+          try {
+            const content = await fs18.readFile(path17.join(this.agentsPath, file), "utf-8");
+            agents.push(JSON.parse(content));
+          } catch (e) {}
+        }
+      }
+      return agents;
+    } catch (error) {
+      return [];
+    }
+  }
+  async getAgent(name) {
+    try {
+      const content = await fs18.readFile(path17.join(this.agentsPath, `${name}.json`), "utf-8");
+      return JSON.parse(content);
+    } catch (error) {
+      return null;
+    }
+  }
+  async createAgent(config) {
+    await this.ensureAgentsDirectory();
+    const filePath = path17.join(this.agentsPath, `${config.name}.json`);
+    await fs18.writeFile(filePath, JSON.stringify(config, null, 2));
+  }
+  async generateAgent(name, description, agent) {
+    const prompt = `Create a configuration for an AI agent named "${name}" based on this description: "${description}".
+    
+    The configuration should be a JSON object matching this interface:
+    interface AgentConfig {
+      name: string;
+      role: string;
+      description: string;
+      model?: string; // suggest a model if appropriate, or leave undefined
+      tools?: string[]; // suggest relevant tools/skills names
+      temperature?: number;
+      systemPrompt?: string; // a detailed system prompt for this agent
+    }
+    
+    Return ONLY the JSON object.`;
+    const response = await agent.processUserMessage(prompt);
+    let jsonData = "";
+    for (const entry of response) {
+      if (entry.type === "assistant") {
+        const match = entry.content.match(/```(?:json)?\n([\s\S]*?)```/);
+        if (match) {
+          jsonData = match[1];
+          break;
+        } else {
+          if (entry.content.trim().startsWith("{")) {
+            jsonData = entry.content;
+          }
+        }
+      }
+    }
+    if (!jsonData) {
+      throw new Error("Failed to generate agent configuration");
+    }
+    try {
+      const config = JSON.parse(jsonData);
+      config.name = name;
+      await this.createAgent(config);
+    } catch (e) {
+      throw new Error(`Failed to parse generated agent config: ${e.message}`);
+    }
+  }
+  async deleteAgent(name) {
+    try {
+      const filePath = path17.join(this.agentsPath, `${name}.json`);
+      await fs18.unlink(filePath);
+    } catch (error) {
+      throw new Error(`Failed to delete agent '${name}'`);
+    }
+  }
+}
+
+// src/commands/agents.ts
+import { Command as Command5 } from "commander";
+import inquirer2 from "inquirer";
+import chalk4 from "chalk";
+function createAgentsCommand() {
+  const agentsCommand = new Command5("agents").description("Manage AI agents");
+  agentsCommand.command("list").description("List available agents").action(async () => {
+    const manager = AgentsManager.getInstance();
+    const agents = await manager.listAgents();
+    if (agents.length === 0) {
+      console.log("No agents found.");
+    } else {
+      console.log("Available agents:");
+      agents.forEach((agent) => {
+        console.log(`- ${chalk4.bold(agent.name)} (${agent.role})`);
+        console.log(`  ${chalk4.dim(agent.description)}`);
+      });
+    }
+  });
+  agentsCommand.command("create <name>").description("Create a new agent with AI assistance").option("-d, --description <description>", "Description of the agent's role and purpose").action(async (name, options) => {
+    try {
+      const manager = AgentsManager.getInstance();
+      const settingsManager = getSettingsManager();
+      let description = options.description;
+      if (!description) {
+        const answer = await inquirer2.prompt([
+          {
+            type: "input",
+            name: "description",
+            message: "Describe the agent's role and purpose:"
+          }
+        ]);
+        description = answer.description;
+      }
+      console.log(chalk4.blue(`Generating agent configuration for '${name}'...`));
+      const apiKey = settingsManager.getApiKey();
+      const baseURL = settingsManager.getBaseURL();
+      const model = settingsManager.getCurrentModel();
+      if (!apiKey) {
+        console.error(chalk4.red("API Key not found. Please configure it first."));
+        return;
+      }
+      const agent = new SuperAgent(apiKey, baseURL, model);
+      await manager.generateAgent(name, description, agent);
+      console.log(chalk4.green(`✓ Agent '${name}' created successfully.`));
+    } catch (error) {
+      console.error(chalk4.red(`Error creating agent: ${error.message}`));
+    }
+  });
+  agentsCommand.command("delete <name>").description("Delete an agent").action(async (name) => {
+    try {
+      const manager = AgentsManager.getInstance();
+      await manager.deleteAgent(name);
+      console.log(chalk4.green(`✓ Agent '${name}' deleted.`));
+    } catch (error) {
+      console.error(chalk4.red(`Error deleting agent: ${error.message}`));
+    }
+  });
+  return agentsCommand;
 }
 
 // src/commands/mcp.ts
 init_config();
-import { Command } from "commander";
-import chalk from "chalk";
+import { Command as Command6 } from "commander";
+import chalk5 from "chalk";
 function createMCPCommand() {
-  const mcpCommand = new Command("mcp");
+  const mcpCommand = new Command6("mcp");
   mcpCommand.description("Manage MCP (Model Context Protocol) servers");
   mcpCommand.command("add <name>").description("Add an MCP server").option("-t, --transport <type>", "Transport type (stdio, http, sse, streamable_http)", "stdio").option("-c, --command <command>", "Command to run the server (for stdio transport)").option("-a, --args [args...]", "Arguments for the server command (for stdio transport)", []).option("-u, --url <url>", "URL for HTTP/SSE transport").option("-h, --headers [headers...]", "HTTP headers (key=value format)", []).option("-e, --env [env...]", "Environment variables (key=value format)", []).action(async (name, options) => {
     try {
       if (PREDEFINED_SERVERS[name]) {
         const config2 = PREDEFINED_SERVERS[name];
         addMCPServer(config2);
-        console.log(chalk.green(`✓ Added predefined MCP server: ${name}`));
+        console.log(chalk5.green(`✓ Added predefined MCP server: ${name}`));
         const manager2 = getMCPManager();
         await manager2.addServer(config2);
-        console.log(chalk.green(`✓ Connected to MCP server: ${name}`));
+        console.log(chalk5.green(`✓ Connected to MCP server: ${name}`));
         const tools2 = manager2.getTools().filter((t) => t.serverName === name);
-        console.log(chalk.blue(`  Available tools: ${tools2.length}`));
+        console.log(chalk5.blue(`  Available tools: ${tools2.length}`));
         return;
       }
       const transportType = options.transport.toLowerCase();
       if (transportType === "stdio") {
         if (!options.command) {
-          console.error(chalk.red("Error: --command is required for stdio transport"));
+          console.error(chalk5.red("Error: --command is required for stdio transport"));
           process.exit(1);
         }
       } else if (transportType === "http" || transportType === "sse" || transportType === "streamable_http") {
         if (!options.url) {
-          console.error(chalk.red(`Error: --url is required for ${transportType} transport`));
+          console.error(chalk5.red(`Error: --url is required for ${transportType} transport`));
           process.exit(1);
         }
       } else {
-        console.error(chalk.red("Error: Transport type must be stdio, http, sse, or streamable_http"));
+        console.error(chalk5.red("Error: Transport type must be stdio, http, sse, or streamable_http"));
         process.exit(1);
       }
       const env = {};
@@ -8483,14 +9034,14 @@ function createMCPCommand() {
         }
       };
       addMCPServer(config);
-      console.log(chalk.green(`✓ Added MCP server: ${name}`));
+      console.log(chalk5.green(`✓ Added MCP server: ${name}`));
       const manager = getMCPManager();
       await manager.addServer(config);
-      console.log(chalk.green(`✓ Connected to MCP server: ${name}`));
+      console.log(chalk5.green(`✓ Connected to MCP server: ${name}`));
       const tools = manager.getTools().filter((t) => t.serverName === name);
-      console.log(chalk.blue(`  Available tools: ${tools.length}`));
+      console.log(chalk5.blue(`  Available tools: ${tools.length}`));
     } catch (error) {
-      console.error(chalk.red(`Error adding MCP server: ${error.message}`));
+      console.error(chalk5.red(`Error adding MCP server: ${error.message}`));
       process.exit(1);
     }
   });
@@ -8500,7 +9051,7 @@ function createMCPCommand() {
       try {
         config = JSON.parse(jsonConfig);
       } catch (error) {
-        console.error(chalk.red("Error: Invalid JSON configuration"));
+        console.error(chalk5.red("Error: Invalid JSON configuration"));
         process.exit(1);
       }
       const serverConfig = {
@@ -8525,14 +9076,14 @@ function createMCPCommand() {
         }
       }
       addMCPServer(serverConfig);
-      console.log(chalk.green(`✓ Added MCP server: ${name}`));
+      console.log(chalk5.green(`✓ Added MCP server: ${name}`));
       const manager = getMCPManager();
       await manager.addServer(serverConfig);
-      console.log(chalk.green(`✓ Connected to MCP server: ${name}`));
+      console.log(chalk5.green(`✓ Connected to MCP server: ${name}`));
       const tools = manager.getTools().filter((t) => t.serverName === name);
-      console.log(chalk.blue(`  Available tools: ${tools.length}`));
+      console.log(chalk5.blue(`  Available tools: ${tools.length}`));
     } catch (error) {
-      console.error(chalk.red(`Error adding MCP server: ${error.message}`));
+      console.error(chalk5.red(`Error adding MCP server: ${error.message}`));
       process.exit(1);
     }
   });
@@ -8541,9 +9092,9 @@ function createMCPCommand() {
       const manager = getMCPManager();
       await manager.removeServer(name);
       removeMCPServer(name);
-      console.log(chalk.green(`✓ Removed MCP server: ${name}`));
+      console.log(chalk5.green(`✓ Removed MCP server: ${name}`));
     } catch (error) {
-      console.error(chalk.red(`Error removing MCP server: ${error.message}`));
+      console.error(chalk5.red(`Error removing MCP server: ${error.message}`));
       process.exit(1);
     }
   });
@@ -8551,15 +9102,15 @@ function createMCPCommand() {
     const config = loadMCPConfig();
     const manager = getMCPManager();
     if (config.servers.length === 0) {
-      console.log(chalk.yellow("No MCP servers configured"));
+      console.log(chalk5.yellow("No MCP servers configured"));
       return;
     }
-    console.log(chalk.bold("Configured MCP servers:"));
+    console.log(chalk5.bold("Configured MCP servers:"));
     console.log();
     for (const server of config.servers) {
       const isConnected = manager.getServers().includes(server.name);
-      const status = isConnected ? chalk.green("✓ Connected") : chalk.red("✗ Disconnected");
-      console.log(`${chalk.bold(server.name)}: ${status}`);
+      const status = isConnected ? chalk5.green("✓ Connected") : chalk5.red("✗ Disconnected");
+      console.log(`${chalk5.bold(server.name)}: ${status}`);
       if (server.transport) {
         console.log(`  Transport: ${server.transport.type}`);
         if (server.transport.type === "stdio") {
@@ -8592,15 +9143,15 @@ function createMCPCommand() {
       const config = loadMCPConfig();
       const serverConfig = config.servers.find((s) => s.name === name);
       if (!serverConfig) {
-        console.error(chalk.red(`Server ${name} not found`));
+        console.error(chalk5.red(`Server ${name} not found`));
         process.exit(1);
       }
-      console.log(chalk.blue(`Testing connection to ${name}...`));
+      console.log(chalk5.blue(`Testing connection to ${name}...`));
       const manager = getMCPManager();
       await manager.addServer(serverConfig);
       const tools = manager.getTools().filter((t) => t.serverName === name);
-      console.log(chalk.green(`✓ Successfully connected to ${name}`));
-      console.log(chalk.blue(`  Available tools: ${tools.length}`));
+      console.log(chalk5.green(`✓ Successfully connected to ${name}`));
+      console.log(chalk5.blue(`  Available tools: ${tools.length}`));
       if (tools.length > 0) {
         console.log("  Tools:");
         tools.forEach((tool) => {
@@ -8609,82 +9160,44 @@ function createMCPCommand() {
         });
       }
     } catch (error) {
-      console.error(chalk.red(`✗ Failed to connect to ${name}: ${error.message}`));
+      console.error(chalk5.red(`✗ Failed to connect to ${name}: ${error.message}`));
       process.exit(1);
     }
   });
   return mcpCommand;
 }
 
-// src/index.ts
-var import__package = __toESM(require_package(), 1);
-import { program } from "commander";
-import * as dotenv from "dotenv";
-import { render } from "ink";
-import React4 from "react";
-dotenv.config();
-process.on("SIGTERM", () => {
-  if (process.stdin.isTTY && process.stdin.setRawMode) {
-    try {
-      process.stdin.setRawMode(false);
-    } catch (e) {}
-  }
-  console.log(`
-Gracefully shutting down...`);
-  process.exit(0);
-});
-process.on("uncaughtException", (error) => {
-  console.error("Uncaught exception:", error);
-  process.exit(1);
-});
-process.on("unhandledRejection", (reason, promise) => {
-  console.error("Unhandled rejection at:", promise, "reason:", reason);
-  process.exit(1);
-});
-function ensureUserSettingsDirectory() {
-  try {
-    const manager = getSettingsManager();
-    manager.loadUserSettings();
-  } catch (error) {}
-}
-function loadApiKey() {
+// src/commands/git.ts
+init_settings_manager();
+import { Command as Command7 } from "commander";
+async function loadApiKey() {
   const manager = getSettingsManager();
   return manager.getApiKey();
 }
-function loadBaseURL() {
+async function loadBaseURL() {
   const manager = getSettingsManager();
   return manager.getBaseURL();
 }
+async function loadModel() {
+  const manager = getSettingsManager();
+  return process.env.SUPER_AGENT_MODEL || manager.getCurrentModel();
+}
 async function saveCommandLineSettings(apiKey, baseURL) {
-  try {
-    const manager = getSettingsManager();
-    const settings = manager.loadUserSettings();
-    const activeProviderId = settings.active_provider;
-    if (!settings.providers[activeProviderId]) {
-      return;
-    }
+  if (!apiKey && !baseURL) {
+    return;
+  }
+  const manager = getSettingsManager();
+  const settings = manager.loadUserSettings();
+  const activeProviderId = settings.active_provider;
+  if (settings.providers[activeProviderId]) {
     if (apiKey) {
       settings.providers[activeProviderId].api_key = apiKey;
-      console.log(`✅ API key saved for provider '${activeProviderId}' to ~/.super-agent/settings.json`);
     }
     if (baseURL) {
       settings.providers[activeProviderId].base_url = baseURL;
-      console.log(`✅ Base URL saved for provider '${activeProviderId}' to ~/.super-agent/settings.json`);
     }
     manager.saveUserSettings(settings);
-  } catch (error) {
-    console.warn("⚠️ Could not save settings to file:", error instanceof Error ? error.message : "Unknown error");
-  }
-}
-function loadModel() {
-  let model = process.env.SUPER_AGENT_MODEL;
-  if (!model) {
-    try {
-      const manager = getSettingsManager();
-      model = manager.getCurrentModel();
-    } catch (error) {}
   }
-  return model;
 }
 async function handleCommitAndPushHeadless(apiKey, baseURL, model, maxToolRounds) {
   try {
@@ -8759,6 +9272,120 @@ Respond with ONLY the commit message, no additional text.`;
     process.exit(1);
   }
 }
+function createGitCommand() {
+  const gitCommand = new Command7("git").description("Git operations with AI assistance");
+  gitCommand.command("commit-and-push").description("Generate AI commit message and push to remote").option("-d, --directory <dir>", "set working directory", process.cwd()).option("-k, --api-key <key>", "Super Agent API key (or set SUPER_AGENT_API_KEY env var)").option("-u, --base-url <url>", "Super Agent API base URL (or set SUPER_AGENT_BASE_URL env var)").option("-m, --model <model>", "AI model to use (e.g., GLM-4.7) (or set SUPER_AGENT_MODEL env var)").option("--max-tool-rounds <rounds>", "maximum number of tool execution rounds (default: 400)", "400").action(async (options) => {
+    if (options.directory) {
+      try {
+        process.chdir(options.directory);
+      } catch (error) {
+        console.error(`Error changing directory to ${options.directory}:`, error.message);
+        process.exit(1);
+      }
+    }
+    try {
+      const apiKey = options.apiKey || await loadApiKey();
+      const baseURL = options.baseUrl || await loadBaseURL();
+      const model = options.model || await loadModel();
+      const maxToolRounds = parseInt(options.maxToolRounds) || 400;
+      if (!apiKey) {
+        console.error("❌ Error: API key required for git operations. Set SUPER_AGENT_API_KEY environment variable.");
+        process.exit(1);
+      }
+      if (options.apiKey || options.baseUrl) {
+        await saveCommandLineSettings(options.apiKey, options.baseUrl);
+      }
+      await handleCommitAndPushHeadless(apiKey, baseURL, model, maxToolRounds);
+    } catch (error) {
+      console.error("❌ Error during git commit-and-push:", error.message);
+      process.exit(1);
+    }
+  });
+  return gitCommand;
+}
+
+// src/commands/index.ts
+function registerCommands(program) {
+  program.addCommand(createMCPCommand());
+  program.addCommand(createPluginsCommand());
+  program.addCommand(createGitCommand());
+  program.addCommand(createWebCommand());
+  program.addCommand(createServeCommand());
+  program.addCommand(createSkillsCommand());
+  program.addCommand(createAgentsCommand());
+  program.addCommand(createIndexCommand());
+}
+
+// src/index.ts
+var import__package = __toESM(require_package(), 1);
+import { program } from "commander";
+import * as dotenv from "dotenv";
+import { render } from "ink";
+import React4 from "react";
+dotenv.config();
+process.on("SIGTERM", () => {
+  if (process.stdin.isTTY && process.stdin.setRawMode) {
+    try {
+      process.stdin.setRawMode(false);
+    } catch (e) {}
+  }
+  console.log(`
+Gracefully shutting down...`);
+  process.exit(0);
+});
+process.on("uncaughtException", (error) => {
+  console.error("Uncaught exception:", error);
+  process.exit(1);
+});
+process.on("unhandledRejection", (reason, promise) => {
+  console.error("Unhandled rejection at:", promise, "reason:", reason);
+  process.exit(1);
+});
+function ensureUserSettingsDirectory() {
+  try {
+    const manager = getSettingsManager();
+    manager.loadUserSettings();
+  } catch (error) {}
+}
+function loadApiKey2() {
+  const manager = getSettingsManager();
+  return manager.getApiKey();
+}
+function loadBaseURL2() {
+  const manager = getSettingsManager();
+  return manager.getBaseURL();
+}
+async function saveCommandLineSettings2(apiKey, baseURL) {
+  try {
+    const manager = getSettingsManager();
+    const settings = manager.loadUserSettings();
+    const activeProviderId = settings.active_provider;
+    if (!settings.providers[activeProviderId]) {
+      return;
+    }
+    if (apiKey) {
+      settings.providers[activeProviderId].api_key = apiKey;
+      console.log(`✅ API key saved for provider '${activeProviderId}' to ~/.super-agent/settings.json`);
+    }
+    if (baseURL) {
+      settings.providers[activeProviderId].base_url = baseURL;
+      console.log(`✅ Base URL saved for provider '${activeProviderId}' to ~/.super-agent/settings.json`);
+    }
+    manager.saveUserSettings(settings);
+  } catch (error) {
+    console.warn("⚠️ Could not save settings to file:", error instanceof Error ? error.message : "Unknown error");
+  }
+}
+function loadModel2() {
+  let model = process.env.SUPER_AGENT_MODEL;
+  if (!model) {
+    try {
+      const manager = getSettingsManager();
+      model = manager.getCurrentModel();
+    } catch (error) {}
+  }
+  return model;
+}
 async function processPromptHeadless(prompt, apiKey, baseURL, model, maxToolRounds) {
   try {
     const agent = new SuperAgent(apiKey, baseURL, model, maxToolRounds);
@@ -8823,9 +9450,9 @@ program.name("super-agent").description("A conversational AI CLI tool powered by
     }
   }
   try {
-    const apiKey = options.apiKey || loadApiKey();
-    const baseURL = options.baseUrl || loadBaseURL();
-    const model = options.model || loadModel();
+    const apiKey = options.apiKey || loadApiKey2();
+    const baseURL = options.baseUrl || loadBaseURL2();
+    const model = options.model || loadModel2();
     const maxToolRounds = parseInt(options.maxToolRounds) || 400;
     if (!apiKey && !options.prompt) {
       console.warn("⚠️  Warning: No API key found. Some features may not work. Use /config or set SUPER_AGENT_API_KEY.");
@@ -8834,7 +9461,7 @@ program.name("super-agent").description("A conversational AI CLI tool powered by
       process.exit(1);
     }
     if (options.apiKey || options.baseUrl) {
-      await saveCommandLineSettings(options.apiKey, options.baseUrl);
+      await saveCommandLineSettings2(options.apiKey, options.baseUrl);
     }
     if (options.prompt) {
       await processPromptHeadless(options.prompt, apiKey, baseURL, model, maxToolRounds);
@@ -8862,141 +9489,6 @@ program.name("super-agent").description("A conversational AI CLI tool powered by
     process.exit(1);
   }
 });
-var aboutCommand = program.command("about").description("Show information about the Super Agent CLI").action(() => {
-  console.log(import__package.default.name + " " + import__package.default.version);
-  console.log(import__package.default.description);
-  console.log(`
-Maintained by: ` + import__package.default.author);
-  console.log(`
-Source code: ` + import__package.default.repository.url);
-  console.log(`
-Funding: ` + import__package.default.funding);
-  process.exit(0);
-});
-var pluginsCommand = program.command("plugins list/install/uninstall <name> / <path>").description("Manage plugins for Super Agent CLI");
-pluginsCommand.command("list").description("List installed plugins").action(() => {
-  console.log("List installed plugins");
-  process.exit(0);
-});
-pluginsCommand.command("install <name> / <path>").description("Install a plugin").action(() => {
-  console.log("Install a plugin");
-  process.exit(0);
-});
-pluginsCommand.command("uninstall <name>").description("Uninstall a plugin").action(() => {
-  console.log("Uninstall a plugin");
-  process.exit(0);
-});
-var gitCommand = program.command("git").description("Git operations with AI assistance");
-gitCommand.command("commit-and-push").description("Generate AI commit message and push to remote").option("-d, --directory <dir>", "set working directory", process.cwd()).option("-k, --api-key <key>", "Super Agent API key (or set SUPER_AGENT_API_KEY env var)").option("-u, --base-url <url>", "Super Agent API base URL (or set SUPER_AGENT_BASE_URL env var)").option("-m, --model <model>", "AI model to use (e.g., GLM-4.7) (or set SUPER_AGENT_MODEL env var)").option("--max-tool-rounds <rounds>", "maximum number of tool execution rounds (default: 400)", "400").action(async (options) => {
-  if (options.directory) {
-    try {
-      process.chdir(options.directory);
-    } catch (error) {
-      console.error(`Error changing directory to ${options.directory}:`, error.message);
-      process.exit(1);
-    }
-  }
-  try {
-    const apiKey = options.apiKey || loadApiKey();
-    const baseURL = options.baseUrl || loadBaseURL();
-    const model = options.model || loadModel();
-    const maxToolRounds = parseInt(options.maxToolRounds) || 400;
-    if (!apiKey) {
-      console.error("❌ Error: API key required for git operations. Set SUPER_AGENT_API_KEY environment variable.");
-      process.exit(1);
-    }
-    if (options.apiKey || options.baseUrl) {
-      await saveCommandLineSettings(options.apiKey, options.baseUrl);
-    }
-    await handleCommitAndPushHeadless(apiKey, baseURL, model, maxToolRounds);
-  } catch (error) {
-    console.error("❌ Error during git commit-and-push:", error.message);
-    process.exit(1);
-  }
-});
-var webCommand = program.command("web").description("Start web server interface").option("--hostname <hostname>", "Server hostname", "localhost").option("--port <port>", "Server port", "3000").option("-d, --directory <dir>", "set working directory", process.cwd()).option("-k, --api-key <key>", "Super Agent API key (or set SUPER_AGENT_API_KEY env var)").option("-u, --base-url <url>", "Super Agent API base URL (or set SUPER_AGENT_BASE_URL env var)").option("-m, --model <model>", "AI model to use (e.g., GLM-4.7) (or set SUPER_AGENT_MODEL env var)").option("--max-tool-rounds <rounds>", "maximum number of tool execution rounds (default: 400)", "400").option("--no-open", "Don't open browser automatically").action(async (options) => {
-  if (options.directory) {
-    try {
-      process.chdir(options.directory);
-    } catch (error) {
-      console.error(`Error changing directory to ${options.directory}:`, error.message);
-      process.exit(1);
-    }
-  }
-  try {
-    const { WebServer: WebServer2 } = await Promise.resolve().then(() => (init_server(), exports_server));
-    const apiKey = options.apiKey || loadApiKey();
-    const baseURL = options.baseUrl || loadBaseURL();
-    const model = options.model || loadModel();
-    const maxToolRounds = parseInt(options.maxToolRounds) || 400;
-    if (!apiKey) {
-      console.warn("⚠️  Warning: No API key found. Web interface may not work properly.");
-    }
-    if (options.apiKey || options.baseUrl) {
-      await saveCommandLineSettings(options.apiKey, options.baseUrl);
-    }
-    const agent = new SuperAgent(apiKey || "", baseURL, model, maxToolRounds);
-    const server = new WebServer2({
-      hostname: options.hostname,
-      port: parseInt(options.port),
-      agent
-    });
-    await server.start();
-    if (options.open !== false) {
-      await server.openBrowser();
-    }
-    process.on("SIGINT", () => {
-      server.stop();
-      process.exit(0);
-    });
-  } catch (error) {
-    console.error("❌ Error starting web server:", error.message);
-    process.exit(1);
-  }
-});
-var serveCommand = program.command("serve").description("Run both CLI and web interface simultaneously").option("--hostname <hostname>", "Server hostname", "localhost").option("--port <port>", "Server port", "3000").option("-d, --directory <dir>", "set working directory", process.cwd()).option("-k, --api-key <key>", "Super Agent API key (or set SUPER_AGENT_API_KEY env var)").option("-u, --base-url <url>", "Super Agent API base URL (or set SUPER_AGENT_BASE_URL env var)").option("-m, --model <model>", "AI model to use (e.g., GLM-4.7) (or set SUPER_AGENT_MODEL env var)").option("--max-tool-rounds <rounds>", "maximum number of tool execution rounds (default: 400)", "400").option("--no-open", "Don't open browser automatically").action(async (options) => {
-  if (options.directory) {
-    try {
-      process.chdir(options.directory);
-    } catch (error) {
-      console.error(`Error changing directory to ${options.directory}:`, error.message);
-      process.exit(1);
-    }
-  }
-  try {
-    const { WebServer: WebServer2 } = await Promise.resolve().then(() => (init_server(), exports_server));
-    const apiKey = options.apiKey || loadApiKey();
-    const baseURL = options.baseUrl || loadBaseURL();
-    const model = options.model || loadModel();
-    const maxToolRounds = parseInt(options.maxToolRounds) || 400;
-    if (!apiKey) {
-      console.warn("⚠️  Warning: No API key found. Some features may not work.");
-    }
-    if (options.apiKey || options.baseUrl) {
-      await saveCommandLineSettings(options.apiKey, options.baseUrl);
-    }
-    const agent = new SuperAgent(apiKey || "", baseURL, model, maxToolRounds);
-    const server = new WebServer2({
-      hostname: options.hostname,
-      port: parseInt(options.port),
-      agent
-    });
-    await server.start();
-    if (options.open !== false) {
-      await server.openBrowser();
-    }
-    console.log(`\uD83E\uDD16 Starting CLI interface...
-`);
-    ensureUserSettingsDirectory();
-    render(React4.createElement(ChatInterface, { agent }));
-    process.on("SIGINT", () => {
-      server.stop();
-      process.exit(0);
-    });
-  } catch (error) {
-    console.error("❌ Error starting serve mode:", error.message);
-    process.exit(1);
-  }
-});
-program.addCommand(createMCPCommand());
+registerCommands(program);
+program.parse();
 program.parse();