agor-live 0.3.7

package/dist/cli/commands/init.js

@@ -0,0 +1,459 @@
+// src/commands/init.ts
+import { access, constants, mkdir, readdir, rm } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import { setConfigValue } from "@agor/core/config";
+import { createDatabase, createUser, initializeDatabase, seedInitialData } from "@agor/core/db";
+import { Command, Flags } from "@oclif/core";
+import chalk from "chalk";
+import inquirer from "inquirer";
+var Init = class _Init extends Command {
+  static description = "Initialize Agor environment (creates ~/.agor/ and database)";
+  static examples = [
+    "<%= config.bin %> <%= command.id %>",
+    "<%= config.bin %> <%= command.id %> --local"
+  ];
+  static flags = {
+    local: Flags.boolean({
+      char: "l",
+      description: "Initialize local .agor/ directory in current working directory",
+      default: false
+    }),
+    force: Flags.boolean({
+      char: "f",
+      description: "Force re-initialization without prompts (deletes database, repos, and worktrees)",
+      default: false
+    })
+  };
+  async pathExists(path) {
+    try {
+      await access(path, constants.F_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  expandHome(path) {
+    if (path.startsWith("~/")) {
+      return join(homedir(), path.slice(2));
+    }
+    return path;
+  }
+  /**
+   * Count rows in database tables for display
+   */
+  async getDbStats(dbPath) {
+    try {
+      const { createDatabase: createDatabase2, sessions, tasks, messages, repos } = await import("@agor/core/db");
+      const db = createDatabase2({ url: `file:${dbPath}` });
+      const sessionRows = await db.select({ id: sessions.session_id }).from(sessions).all();
+      const taskRows = await db.select({ id: tasks.task_id }).from(tasks).all();
+      const messageRows = await db.select({ id: messages.message_id }).from(messages).all();
+      const repoRows = await db.select({ id: repos.repo_id }).from(repos).all();
+      return {
+        sessions: sessionRows.length,
+        tasks: taskRows.length,
+        messages: messageRows.length,
+        repos: repoRows.length
+      };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * List directories in a path (repos, worktrees)
+   */
+  async listDirs(path) {
+    try {
+      const entries = await readdir(path, { withFileTypes: true });
+      return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Detect if running in GitHub Codespaces
+   */
+  isCodespaces() {
+    return process.env.CODESPACES === "true" || process.env.CODESPACE_NAME !== void 0;
+  }
+  async run() {
+    const { flags } = await this.parse(_Init);
+    this.log("\u2728 Initializing Agor...\n");
+    if (this.isCodespaces() && !flags.force) {
+      this.log(chalk.cyan.bold("\u{1F680} GitHub Codespaces detected!\n"));
+      this.log(chalk.yellow("\u26A0\uFE0F  Sandbox Mode:"));
+      this.log("   - Data persists only while Codespace is active");
+      this.log("   - Stopped Codespaces retain data for 30 days");
+      this.log("   - Rebuilt Codespaces lose all data\n");
+      this.log(chalk.dim("For production use, install Agor locally:"));
+      this.log(chalk.dim("  https://github.com/mistercrunch/agor#installation\n"));
+    }
+    try {
+      const baseDir = flags.local ? join(process.cwd(), ".agor") : join(homedir(), ".agor");
+      const dbPath = join(baseDir, "agor.db");
+      const reposDir = join(baseDir, "repos");
+      const worktreesDir = join(baseDir, "worktrees");
+      const alreadyExists = await this.pathExists(baseDir);
+      const dbExists = await this.pathExists(dbPath);
+      const reposExist = await this.pathExists(reposDir);
+      const worktreesExist = await this.pathExists(worktreesDir);
+      if (!alreadyExists) {
+        await this.performInit(baseDir, dbPath, flags.force);
+        return;
+      }
+      this.log(chalk.yellow("\u26A0  Agor is already initialized at: ") + chalk.cyan(baseDir));
+      this.log("");
+      const dbStats = dbExists ? await this.getDbStats(dbPath) : null;
+      const repos = reposExist ? await this.listDirs(reposDir) : [];
+      const worktrees = worktreesExist ? await this.listDirs(worktreesDir) : [];
+      this.log(chalk.bold.red("\u26A0  Re-initialization will delete:"));
+      this.log("");
+      if (dbExists && dbStats) {
+        this.log(`${chalk.cyan("  Database:")} ${dbPath}`);
+        this.log(
+          chalk.dim(
+            `    ${dbStats.sessions} sessions, ${dbStats.tasks} tasks, ${dbStats.messages} messages, ${dbStats.repos} repos`
+          )
+        );
+      } else if (dbExists) {
+        this.log(`${chalk.cyan("  Database:")} ${dbPath}`);
+      }
+      if (repos.length > 0) {
+        this.log(`${chalk.cyan("  Repos:")} ${reposDir}`);
+        for (const repo of repos.slice(0, 5)) {
+          this.log(chalk.dim(`    - ${repo}`));
+        }
+        if (repos.length > 5) {
+          this.log(chalk.dim(`    ... and ${repos.length - 5} more`));
+        }
+      }
+      if (worktrees.length > 0) {
+        this.log(`${chalk.cyan("  Worktrees:")} ${worktreesDir}`);
+        for (const wt of worktrees.slice(0, 5)) {
+          this.log(chalk.dim(`    - ${wt}`));
+        }
+        if (worktrees.length > 5) {
+          this.log(chalk.dim(`    ... and ${worktrees.length - 5} more`));
+        }
+      }
+      this.log("");
+      if (flags.force) {
+        this.log(chalk.yellow("\u{1F5D1}\uFE0F  --force flag set: deleting everything without prompts..."));
+        await this.cleanupExisting(baseDir, dbPath, reposDir, worktreesDir);
+        await this.performInit(baseDir, dbPath, true);
+        return;
+      }
+      const { confirmed } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "confirmed",
+          message: "Delete all existing data and re-initialize?",
+          default: false
+        }
+      ]);
+      if (!confirmed) {
+        this.log(chalk.dim("Cancelled. Use --force to skip this prompt."));
+        process.exit(0);
+        return;
+      }
+      await this.cleanupExisting(baseDir, dbPath, reposDir, worktreesDir);
+      await this.performInit(baseDir, dbPath, false);
+    } catch (error) {
+      this.error(
+        `Failed to initialize Agor: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Clean up existing installation
+   */
+  async cleanupExisting(_baseDir, dbPath, reposDir, worktreesDir) {
+    this.log("");
+    this.log("\u{1F5D1}\uFE0F  Cleaning up existing installation...");
+    if (await this.pathExists(dbPath)) {
+      await rm(dbPath, { force: true });
+      this.log(`${chalk.green("   \u2713")} Deleted database`);
+    }
+    if (await this.pathExists(reposDir)) {
+      await rm(reposDir, { recursive: true, force: true });
+      this.log(`${chalk.green("   \u2713")} Deleted repos`);
+    }
+    if (await this.pathExists(worktreesDir)) {
+      await rm(worktreesDir, { recursive: true, force: true });
+      this.log(`${chalk.green("   \u2713")} Deleted worktrees`);
+    }
+  }
+  /**
+   * Perform fresh initialization
+   */
+  async performInit(baseDir, dbPath, skipPrompts = false) {
+    this.log("");
+    this.log("\u{1F4C1} Creating directory structure...");
+    const dirs = [
+      baseDir,
+      join(baseDir, "repos"),
+      join(baseDir, "worktrees"),
+      join(baseDir, "concepts"),
+      join(baseDir, "logs")
+    ];
+    for (const dir of dirs) {
+      await mkdir(dir, { recursive: true });
+      this.log(`${chalk.green("   \u2713")} ${dir}`);
+    }
+    this.log("");
+    this.log("\u{1F4BE} Setting up database...");
+    const db = createDatabase({ url: `file:${dbPath}` });
+    await initializeDatabase(db);
+    this.log(`${chalk.green("   \u2713")} Created ${dbPath}`);
+    this.log("");
+    this.log("\u{1F331} Seeding initial data...");
+    await seedInitialData(db);
+    this.log(`${chalk.green("   \u2713")} Created Main Board`);
+    if (!skipPrompts) {
+      await this.promptAuthSetup(dbPath);
+      await this.promptApiKeys();
+    }
+    this.log("");
+    this.log(chalk.green.bold("\u2705 Agor initialized successfully!"));
+    this.log("");
+    this.log(`   Database: ${chalk.cyan(dbPath)}`);
+    this.log(`   Repos: ${chalk.cyan(join(baseDir, "repos"))}`);
+    this.log(`   Worktrees: ${chalk.cyan(join(baseDir, "worktrees"))}`);
+    this.log(`   Concepts: ${chalk.cyan(join(baseDir, "concepts"))}`);
+    this.log(`   Logs: ${chalk.cyan(join(baseDir, "logs"))}`);
+    this.log("");
+    if (this.isCodespaces()) {
+      this.log(chalk.bold("\u{1F4DD} API Key Setup (Optional):"));
+      this.log("");
+      this.log("To use AI agents (Claude, Gemini, etc.), set API keys:");
+      this.log("");
+      this.log(chalk.cyan("1. Environment variables (recommended for Codespaces):"));
+      this.log('   export ANTHROPIC_API_KEY="sk-ant-..."');
+      this.log('   export OPENAI_API_KEY="sk-..."');
+      this.log('   export GOOGLE_AI_API_KEY="..."');
+      this.log("");
+      this.log(chalk.cyan("2. Codespaces Secrets (persistent across rebuilds):"));
+      this.log("   GitHub \u2192 Settings \u2192 Codespaces \u2192 Secrets");
+      this.log("   Add keys there and rebuild Codespace");
+      this.log("");
+      this.log(chalk.yellow("\u{1F4A1} Tip: To preserve your work:"));
+      this.log("   - Keep Codespace active (auto-stops after 30 min idle)");
+      this.log("   - Export important sessions before stopping");
+      this.log("   - Use git to commit session transcripts");
+      this.log("");
+    }
+    this.log(chalk.bold("Next steps:"));
+    this.log("   - Run 'agor daemon' to start the daemon");
+    this.log("   - Run 'agor session list' to view all sessions");
+    this.log("");
+  }
+  /**
+   * Prompt user for auth/multiplayer setup
+   */
+  async promptAuthSetup(dbPath) {
+    this.log("");
+    const { enableAuth } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "enableAuth",
+        message: "Enable authentication and multiplayer features?",
+        default: false
+      }
+    ]);
+    if (!enableAuth) {
+      this.log(chalk.gray("Authentication disabled. Running in single-user mode."));
+      this.log("");
+      this.log(chalk.gray("You can enable auth later with:"));
+      this.log(chalk.gray("  agor config set daemon.requireAuth true"));
+      this.log(chalk.gray("  agor user create-admin"));
+      return;
+    }
+    await setConfigValue("daemon.requireAuth", true);
+    await setConfigValue("daemon.allowAnonymous", false);
+    this.log(`${chalk.green("   \u2713")} Enabled authentication`);
+    this.log("");
+    const { createAdmin } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "createAdmin",
+        message: "Create an admin user?",
+        default: true
+      }
+    ]);
+    if (!createAdmin) {
+      this.log("");
+      this.log(chalk.yellow("\u26A0 You must create an admin user before starting the daemon:"));
+      this.log(chalk.gray("  agor user create-admin"));
+      return;
+    }
+    const { email, username, password } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "email",
+        message: "Email:",
+        validate: (input) => {
+          if (!input || !input.includes("@")) {
+            return "Please enter a valid email address";
+          }
+          return true;
+        }
+      },
+      {
+        type: "input",
+        name: "username",
+        message: "Username:",
+        validate: (input) => {
+          if (!input || input.length < 2) {
+            return "Username must be at least 2 characters";
+          }
+          return true;
+        }
+      },
+      {
+        type: "password",
+        name: "password",
+        message: "Password:",
+        mask: "*",
+        validate: (input) => {
+          if (!input || input.length < 4) {
+            return "Password must be at least 4 characters";
+          }
+          return true;
+        }
+      }
+    ]);
+    try {
+      const db = createDatabase({ url: `file:${dbPath}` });
+      const user = await createUser(db, {
+        email,
+        password,
+        name: username,
+        role: "admin"
+      });
+      this.log(
+        chalk.green("   \u2713") + ` Admin user created successfully (ID: ${chalk.gray(user.user_id.substring(0, 8))})`
+      );
+    } catch (error) {
+      this.log("");
+      this.log(chalk.red("\u2717 Failed to create admin user"));
+      if (error instanceof Error) {
+        this.log(chalk.red(`  ${error.message}`));
+      }
+      this.log("");
+      this.log(chalk.gray("You can create an admin user later with:"));
+      this.log(chalk.gray("  agor user create-admin"));
+    }
+  }
+  /**
+   * Prompt user for API key setup
+   */
+  async promptApiKeys() {
+    this.log("");
+    this.log(chalk.bold("\u{1F511} API Key Setup"));
+    this.log("");
+    this.log(chalk.gray("Configure API keys for AI agents (optional, can be set later)"));
+    this.log("");
+    const { setupKeys } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "setupKeys",
+        message: "Set up API keys now?",
+        default: false
+      }
+    ]);
+    if (!setupKeys) {
+      this.log("");
+      this.log(chalk.gray("Skipped. You can set API keys later with:"));
+      this.log(chalk.gray('  agor config set credentials.ANTHROPIC_API_KEY "sk-ant-..."'));
+      this.log(chalk.gray('  agor config set credentials.OPENAI_API_KEY "sk-..."'));
+      this.log(chalk.gray('  agor config set credentials.GEMINI_API_KEY "..."'));
+      return;
+    }
+    const { setupAnthropic } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "setupAnthropic",
+        message: "Set up Anthropic API key (for Claude Code)?",
+        default: true
+      }
+    ]);
+    if (setupAnthropic) {
+      const { anthropicKey } = await inquirer.prompt([
+        {
+          type: "password",
+          name: "anthropicKey",
+          message: "Anthropic API key (sk-ant-...):",
+          mask: "*",
+          validate: (input) => {
+            if (!input || input.length < 10) {
+              return "Please enter a valid API key";
+            }
+            return true;
+          }
+        }
+      ]);
+      await setConfigValue("credentials.ANTHROPIC_API_KEY", anthropicKey);
+      this.log(chalk.green("   \u2713") + " Anthropic API key saved");
+    }
+    const { setupOpenAI } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "setupOpenAI",
+        message: "Set up OpenAI API key (for Codex)?",
+        default: false
+      }
+    ]);
+    if (setupOpenAI) {
+      const { openaiKey } = await inquirer.prompt([
+        {
+          type: "password",
+          name: "openaiKey",
+          message: "OpenAI API key (sk-...):",
+          mask: "*",
+          validate: (input) => {
+            if (!input || input.length < 10) {
+              return "Please enter a valid API key";
+            }
+            return true;
+          }
+        }
+      ]);
+      await setConfigValue("credentials.OPENAI_API_KEY", openaiKey);
+      this.log(chalk.green("   \u2713") + " OpenAI API key saved");
+    }
+    const { setupGemini } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "setupGemini",
+        message: "Set up Google Gemini API key?",
+        default: false
+      }
+    ]);
+    if (setupGemini) {
+      const { geminiKey } = await inquirer.prompt([
+        {
+          type: "password",
+          name: "geminiKey",
+          message: "Google Gemini API key:",
+          mask: "*",
+          validate: (input) => {
+            if (!input || input.length < 10) {
+              return "Please enter a valid API key";
+            }
+            return true;
+          }
+        }
+      ]);
+      await setConfigValue("credentials.GEMINI_API_KEY", geminiKey);
+      this.log(chalk.green("   \u2713") + " Gemini API key saved");
+    }
+    this.log("");
+    this.log(
+      chalk.gray("Note: API keys are stored in ~/.agor/config.yaml (keep this file secure!)")
+    );
+  }
+};
+export {
+  Init as default
+};

package/dist/cli/commands/mcp/add.d.ts

@@ -0,0 +1,26 @@
+import * as _oclif_core_interfaces from '@oclif/core/interfaces';
+import { Command } from '@oclif/core';
+
+declare class McpAdd extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        name: _oclif_core_interfaces.Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        transport: _oclif_core_interfaces.OptionFlag<string, _oclif_core_interfaces.CustomOptions>;
+        command: _oclif_core_interfaces.OptionFlag<string | undefined, _oclif_core_interfaces.CustomOptions>;
+        args: _oclif_core_interfaces.OptionFlag<string | undefined, _oclif_core_interfaces.CustomOptions>;
+        url: _oclif_core_interfaces.OptionFlag<string | undefined, _oclif_core_interfaces.CustomOptions>;
+        scope: _oclif_core_interfaces.OptionFlag<string, _oclif_core_interfaces.CustomOptions>;
+        'session-id': _oclif_core_interfaces.OptionFlag<string | undefined, _oclif_core_interfaces.CustomOptions>;
+        'repo-id': _oclif_core_interfaces.OptionFlag<string | undefined, _oclif_core_interfaces.CustomOptions>;
+        'display-name': _oclif_core_interfaces.OptionFlag<string | undefined, _oclif_core_interfaces.CustomOptions>;
+        description: _oclif_core_interfaces.OptionFlag<string | undefined, _oclif_core_interfaces.CustomOptions>;
+        enabled: _oclif_core_interfaces.BooleanFlag<boolean>;
+        env: _oclif_core_interfaces.OptionFlag<string | undefined, _oclif_core_interfaces.CustomOptions>;
+    };
+    run(): Promise<void>;
+}
+
+export { McpAdd as default };

package/dist/cli/commands/mcp/add.js

@@ -0,0 +1,162 @@
+// src/commands/mcp/add.ts
+import { createClient, isDaemonRunning } from "@agor/core/api";
+import { getDaemonUrl } from "@agor/core/config";
+import { Args, Command, Flags } from "@oclif/core";
+import chalk from "chalk";
+var McpAdd = class _McpAdd extends Command {
+  static description = "Add a new MCP server";
+  static examples = [
+    '<%= config.bin %> <%= command.id %> filesystem --command npx --args "@modelcontextprotocol/server-filesystem,/path/to/allowed"',
+    "<%= config.bin %> <%= command.id %> sentry --transport http --url https://mcp.sentry.dev/mcp",
+    '<%= config.bin %> <%= command.id %> custom-tool --command node --args "dist/server.js" --scope session --session-id 0199b856'
+  ];
+  static args = {
+    name: Args.string({
+      description: "MCP server name (e.g., filesystem, sentry, custom-tool)",
+      required: true
+    })
+  };
+  static flags = {
+    transport: Flags.string({
+      char: "t",
+      description: "Transport type",
+      options: ["stdio", "http", "sse"],
+      default: "stdio"
+    }),
+    command: Flags.string({
+      char: "c",
+      description: "Command to run (for stdio transport)"
+    }),
+    args: Flags.string({
+      char: "a",
+      description: "Command arguments (comma-separated)"
+    }),
+    url: Flags.string({
+      char: "u",
+      description: "Server URL (for http/sse transport)"
+    }),
+    scope: Flags.string({
+      char: "s",
+      description: "Server scope",
+      options: ["global", "team", "repo", "session"],
+      default: "global"
+    }),
+    "session-id": Flags.string({
+      description: "Session ID (required if scope=session)"
+    }),
+    "repo-id": Flags.string({
+      description: "Repo ID (required if scope=repo)"
+    }),
+    "display-name": Flags.string({
+      char: "d",
+      description: "Display name for the server"
+    }),
+    description: Flags.string({
+      description: "Server description"
+    }),
+    enabled: Flags.boolean({
+      description: "Enable server immediately",
+      default: true
+    }),
+    env: Flags.string({
+      char: "e",
+      description: "Environment variables (key=value pairs, comma-separated)"
+    })
+  };
+  async run() {
+    const { args, flags } = await this.parse(_McpAdd);
+    const daemonUrl = await getDaemonUrl();
+    const running = await isDaemonRunning(daemonUrl);
+    if (!running) {
+      this.error(
+        `Daemon not running. Start it with: ${chalk.cyan("cd apps/agor-daemon && pnpm dev")}`
+      );
+    }
+    if (flags.transport === "stdio" && !flags.command) {
+      this.error("--command is required for stdio transport");
+    }
+    if ((flags.transport === "http" || flags.transport === "sse") && !flags.url) {
+      this.error("--url is required for http/sse transport");
+    }
+    if (flags.scope === "session" && !flags["session-id"]) {
+      this.error("--session-id is required when scope=session");
+    }
+    if (flags.scope === "repo" && !flags["repo-id"]) {
+      this.error("--repo-id is required when scope=repo");
+    }
+    try {
+      this.log("");
+      this.log(chalk.bold(`Adding MCP server ${chalk.cyan(args.name)}...`));
+      const data = {
+        name: args.name,
+        display_name: flags["display-name"],
+        description: flags.description,
+        transport: flags.transport,
+        scope: flags.scope,
+        enabled: flags.enabled,
+        source: "user"
+      };
+      if (flags.command) data.command = flags.command;
+      if (flags.args) data.args = flags.args.split(",").map((arg) => arg.trim());
+      if (flags.url) data.url = flags.url;
+      if (flags.env) {
+        const envPairs = flags.env.split(",").map((pair) => pair.trim());
+        const envObject = {};
+        for (const pair of envPairs) {
+          const [key, value] = pair.split("=");
+          if (key && value) {
+            envObject[key.trim()] = value.trim();
+          }
+        }
+        if (Object.keys(envObject).length > 0) {
+          data.env = envObject;
+        }
+      }
+      if (flags["session-id"]) data.session_id = flags["session-id"];
+      if (flags["repo-id"]) data.repo_id = flags["repo-id"];
+      const client = createClient(daemonUrl);
+      const server = await client.service("mcp-servers").create(data);
+      this.log(`${chalk.green("\u2713")} MCP server added`);
+      this.log("");
+      this.log(chalk.bold("Server Details:"));
+      this.log(`  ${chalk.cyan("ID")}: ${String(server.mcp_server_id).substring(0, 8)}`);
+      this.log(`  ${chalk.cyan("Name")}: ${server.name}`);
+      this.log(`  ${chalk.cyan("Transport")}: ${server.transport}`);
+      this.log(`  ${chalk.cyan("Scope")}: ${server.scope}`);
+      this.log(
+        `  ${chalk.cyan("Enabled")}: ${server.enabled ? chalk.green("\u2713") : chalk.gray("\u2717")}`
+      );
+      if (server.command) {
+        this.log(`  ${chalk.cyan("Command")}: ${server.command}`);
+      }
+      if (server.args) {
+        this.log(`  ${chalk.cyan("Args")}: ${server.args.join(", ")}`);
+      }
+      if (server.url) {
+        this.log(`  ${chalk.cyan("URL")}: ${server.url}`);
+      }
+      if (server.env) {
+        const envKeys = Object.keys(server.env);
+        this.log(`  ${chalk.cyan("Environment")}: ${envKeys.join(", ")}`);
+      }
+      this.log("");
+      await new Promise((resolve) => {
+        client.io.once("disconnect", () => resolve());
+        client.io.close();
+        setTimeout(() => resolve(), 1e3);
+      });
+      process.exit(0);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.log("");
+      this.log(chalk.red("\u2717 Failed to add MCP server"));
+      this.log("");
+      this.log(chalk.dim(message));
+      this.log("");
+      process.exit(1);
+    }
+  }
+};
+export {
+  McpAdd as default
+};

package/dist/cli/commands/mcp/list.d.ts

@@ -0,0 +1,16 @@
+import * as _oclif_core_interfaces from '@oclif/core/interfaces';
+import { Command } from '@oclif/core';
+
+declare class McpList extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        scope: _oclif_core_interfaces.OptionFlag<string | undefined, _oclif_core_interfaces.CustomOptions>;
+        transport: _oclif_core_interfaces.OptionFlag<string | undefined, _oclif_core_interfaces.CustomOptions>;
+        enabled: _oclif_core_interfaces.BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private cleanup;
+}
+
+export { McpList as default };