@aigne/cli 1.26.1-1 → 1.27.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## [1.27.0](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.26.0...cli-v1.27.0) (2025-07-30)
+
+
+### Features
+
+* support aigne connect command and add test ([#283](https://github.com/AIGNE-io/aigne-framework/issues/283)) ([387d22d](https://github.com/AIGNE-io/aigne-framework/commit/387d22d5cacf20abe02a13deaca1f36987d48ba5))
+
+
+### Bug Fixes
+
+* **cli:** replace external dependency with built-in user subscription API ([#292](https://github.com/AIGNE-io/aigne-framework/issues/292)) ([67de7fa](https://github.com/AIGNE-io/aigne-framework/commit/67de7fa521626ee7266c6c527e4eafc227bafa48))
+* support aigne connect status more info ([#290](https://github.com/AIGNE-io/aigne-framework/issues/290)) ([04c5a06](https://github.com/AIGNE-io/aigne-framework/commit/04c5a0625938a7c1ca1d6fd997f6e9047d425ea0))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/aigne-hub bumped to 0.3.0
+
 ## [1.26.0](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.25.1...cli-v1.26.0) (2025-07-28)
 
 

package/dist/cli.js

@@ -2,7 +2,6 @@
 import { existsSync, realpathSync, statSync } from "node:fs";
 import chalk from "chalk";
 import { config } from "dotenv-flow";
-import { hideBin } from "yargs/helpers";
 import { createAIGNECommand } from "./commands/aigne.js";
 config({ silent: true });
 function getAIGNEFilePath() {
@@ -17,7 +16,7 @@ function getAIGNEFilePath() {
 }
 const aigneFilePath = getAIGNEFilePath();
 createAIGNECommand({ aigneFilePath })
-    .parseAsync(hideBin([...process.argv.slice(0, 2), ...process.argv.slice(aigneFilePath ? 3 : 2)]))
+    .parseAsync(["", "", ...process.argv.slice(aigneFilePath ? 3 : 2)])
     .catch((error) => {
     console.log(""); // Add an empty line for better readability
     console.error(`${chalk.red("Error:")} ${error.message}`);

package/dist/commands/aigne.d.ts

@@ -1,4 +1,4 @@
-import yargs from "yargs";
+import { Command } from "commander";
 export declare function createAIGNECommand(options?: {
     aigneFilePath?: string;
-}): yargs.Argv<{}>;
+}): Command;

package/dist/commands/aigne.js

@@ -1,7 +1,6 @@
-import yargs from "yargs";
+import { Command } from "commander";
 import { AIGNE_CLI_VERSION } from "../constants.js";
 import { asciiLogo } from "../utils/ascii-logo.js";
-import { createAppCommands } from "./app.js";
 import { createConnectCommand } from "./connect.js";
 import { createCreateCommand } from "./create.js";
 import { createObservabilityCommand } from "./observe.js";
@@ -10,20 +9,16 @@ import { createServeMCPCommand } from "./serve-mcp.js";
 import { createTestCommand } from "./test.js";
 export function createAIGNECommand(options) {
     console.log(asciiLogo);
-    return yargs()
-        .scriptName("aigne")
-        .usage("CLI for AIGNE framework")
+    return new Command()
+        .name("aigne")
+        .description("CLI for AIGNE framework")
         .version(AIGNE_CLI_VERSION)
-        .command(createRunCommand(options))
-        .command(createTestCommand(options))
-        .command(createCreateCommand())
-        .command(createServeMCPCommand(options))
-        .command(createObservabilityCommand())
-        .command(createConnectCommand())
-        .command(createAppCommands())
-        .help()
-        .alias("help", "h")
-        .alias("version", "v")
-        .showHelpOnFail(true)
-        .strict();
+        .addCommand(createRunCommand(options), { isDefault: true })
+        .addCommand(createTestCommand(options))
+        .addCommand(createCreateCommand())
+        .addCommand(createServeMCPCommand(options))
+        .addCommand(createObservabilityCommand())
+        .addCommand(createConnectCommand())
+        .showHelpAfterError(true)
+        .showSuggestionAfterError(true);
 }

package/dist/commands/connect.d.ts

@@ -1,6 +1,2 @@
-import type { CommandModule } from "yargs";
-interface ConnectOptions {
-    url?: string;
-}
-export declare function createConnectCommand(): CommandModule<{}, ConnectOptions>;
-export {};
+import { Command } from "commander";
+export declare function createConnectCommand(): Command;

package/dist/commands/connect.js

@@ -1,8 +1,9 @@
 import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
-import { getUserInfo } from "@blocklet/aigne-hub/api/user";
 import chalk from "chalk";
+import { Command } from "commander";
 import { parse } from "yaml";
+import { getUserInfo } from "../utils/aigne-hub-user.js";
 import { AIGNE_ENV_FILE, connectToAIGNEHub } from "../utils/load-aigne.js";
 async function getConnectionStatus() {
     if (!existsSync(AIGNE_ENV_FILE)) {
@@ -56,36 +57,30 @@ async function displayStatus(statusList) {
     }
 }
 export function createConnectCommand() {
-    return {
-        command: "connect [url]",
-        describe: "Manage AIGNE Hub connections",
-        builder: (yargs) => {
-            return yargs
-                .positional("url", {
-                describe: "URL to the AIGNE Hub server",
-                type: "string",
-                default: "https://hub.aigne.io/",
-            })
-                .command({
-                command: "status",
-                describe: "Show current connection status",
-                handler: async () => {
-                    const statusList = await getConnectionStatus();
-                    await displayStatus(statusList);
-                },
-            });
-        },
-        handler: async (argv) => {
-            const url = argv.url || "https://hub.aigne.io/";
-            console.log(chalk.blue(`Connecting to AIGNE Hub: ${url}`));
-            try {
-                await connectToAIGNEHub(url);
-                console.log(chalk.green("✓ Successfully connected to AIGNE Hub"));
-            }
-            catch (error) {
-                console.error(chalk.red("✗ Failed to connect to AIGNE Hub:"), error.message);
-                process.exit(1);
-            }
-        },
-    };
+    const connectCommand = new Command("connect")
+        .description("Manage AIGNE Hub connections")
+        .showHelpAfterError(true)
+        .showSuggestionAfterError(true);
+    connectCommand
+        .command("status")
+        .description("Show current connection status")
+        .action(async () => {
+        const statusList = await getConnectionStatus();
+        await displayStatus(statusList);
+    });
+    connectCommand
+        .option("--url <url>", "URL to the AIGNE Hub server")
+        .action(async (options) => {
+        const url = options.url || "https://hub.aigne.io/";
+        console.log(chalk.blue(`Connecting to AIGNE Hub: ${url}`));
+        try {
+            await connectToAIGNEHub(url);
+            console.log(chalk.green("✓ Successfully connected to AIGNE Hub"));
+        }
+        catch (error) {
+            console.error(chalk.red("✗ Failed to connect to AIGNE Hub:"), error.message);
+            process.exit(1);
+        }
+    });
+    return connectCommand;
 }

package/dist/commands/create.d.ts

@@ -1,6 +1,2 @@
-import type { CommandModule } from "yargs";
-interface CreateOptions {
-    path: string;
-}
-export declare function createCreateCommand(): CommandModule<{}, CreateOptions>;
-export {};
+import { Command } from "commander";
+export declare function createCreateCommand(): Command;

package/dist/commands/create.js

@@ -1,73 +1,69 @@
 import { existsSync, mkdirSync, readdirSync } from "node:fs";
 import { cp } from "node:fs/promises";
 import { isAbsolute, join, relative, resolve } from "node:path";
+import { Command } from "commander";
 import inquirer from "inquirer";
 export function createCreateCommand() {
-    return {
-        command: "create [path]",
-        describe: "Create a new aigne project with agent config files",
-        builder: (yargs) => {
-            return yargs.positional("path", {
-                describe: "Path to create the project directory",
-                type: "string",
-                default: ".",
-            });
-        },
-        handler: async ({ path }) => {
-            if (path === ".") {
-                const answers = await inquirer.prompt([
-                    {
-                        type: "input",
-                        name: "projectName",
-                        message: "Project name:",
-                        default: path !== "." ? path : "my-aigne-project",
-                        validate: (input) => {
-                            if (input.trim() === "")
-                                return "Project name cannot be empty.";
-                            return true;
-                        },
-                    },
-                ]);
-                path = answers.projectName;
-            }
-            path = isAbsolute(path) ? path : resolve(process.cwd(), path);
-            const isPathNotEmpty = existsSync(path) && readdirSync(path).length > 0;
-            if (isPathNotEmpty) {
-                const answers = await inquirer.prompt([
-                    {
-                        type: "confirm",
-                        name: "overwrite",
-                        message: `The directory "${path}" is not empty. Do you want to remove its contents?`,
-                        default: false,
+    return new Command("create")
+        .description("Create a new aigne project with agent config files")
+        .argument("[path]", "Path to create the project directory", ".")
+        .action(async (_path) => {
+        let path = _path;
+        if (path === ".") {
+            const answers = await inquirer.prompt([
+                {
+                    type: "input",
+                    name: "projectName",
+                    message: "Project name:",
+                    default: _path !== "." ? _path : "my-aigne-project",
+                    validate: (input) => {
+                        if (input.trim() === "")
+                            return "Project name cannot be empty.";
+                        return true;
                     },
-                ]);
-                if (!answers.overwrite) {
-                    console.log("Operation cancelled.");
-                    process.exit(0);
-                }
-            }
-            const templates = [{ name: "default" }];
-            const { template } = await inquirer.prompt([
+                },
+            ]);
+            path = answers.projectName;
+        }
+        path = isAbsolute(path) ? path : resolve(process.cwd(), path);
+        const isPathNotEmpty = existsSync(path) && readdirSync(path).length > 0;
+        if (isPathNotEmpty) {
+            const answers = await inquirer.prompt([
                 {
-                    type: "list",
-                    name: "template",
-                    message: "Select a template:",
-                    choices: templates.map((t) => t.name),
-                    default: "default",
+                    type: "confirm",
+                    name: "overwrite",
+                    message: `The directory "${path}" is not empty. Do you want to remove its contents?`,
+                    default: false,
                 },
             ]);
-            mkdirSync(path, { recursive: true });
-            const templatePath = join(import.meta.dirname, "../../templates", template);
-            if (!existsSync(templatePath))
-                throw new Error(`Template "${template}" not found.`);
-            const files = readdirSync(templatePath);
-            for (const file of files) {
-                const source = join(templatePath, file);
-                const destination = join(path, file);
-                await cp(source, destination, { recursive: true, force: true });
+            if (!answers.overwrite) {
+                console.log("Operation cancelled.");
+                process.exit(0);
             }
-            console.log("\n✅ AIGNE project created successfully!");
-            console.log(`\nTo use your new agent, run:\n  cd ${relative(process.cwd(), path)} && aigne run`);
-        },
-    };
+        }
+        const templates = [{ name: "default" }];
+        const { template } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "template",
+                message: "Select a template:",
+                choices: templates.map((t) => t.name),
+                default: "default",
+            },
+        ]);
+        mkdirSync(path, { recursive: true });
+        const templatePath = join(import.meta.dirname, "../../templates", template);
+        if (!existsSync(templatePath))
+            throw new Error(`Template "${template}" not found.`);
+        const files = readdirSync(templatePath);
+        for (const file of files) {
+            const source = join(templatePath, file);
+            const destination = join(path, file);
+            await cp(source, destination, { recursive: true, force: true });
+        }
+        console.log("\n✅ AIGNE project created successfully!");
+        console.log(`\nTo use your new agent, run:\n  cd ${relative(process.cwd(), path)} && aigne run`);
+    })
+        .showHelpAfterError(true)
+        .showSuggestionAfterError(true);
 }

package/dist/commands/observe.d.ts

@@ -1,7 +1,2 @@
-import type { CommandModule } from "yargs";
-interface ServeMCPOptions {
-    host: string;
-    port?: number;
-}
-export declare function createObservabilityCommand(): CommandModule<{}, ServeMCPOptions>;
-export {};
+import { Command } from "commander";
+export declare function createObservabilityCommand(): Command;

package/dist/commands/observe.js

@@ -2,6 +2,7 @@ import { tryOrThrow } from "@aigne/core/utils/type-utils.js";
 import { startObservabilityCLIServer } from "@aigne/observability-api/cli";
 import getObservabilityDbPath from "@aigne/observability-api/db-path";
 import chalk from "chalk";
+import { Command } from "commander";
 import detectPort from "detect-port";
 const DEFAULT_PORT = () => tryOrThrow(() => {
     const { PORT } = process.env;
@@ -13,26 +14,16 @@ const DEFAULT_PORT = () => tryOrThrow(() => {
     return port;
 }, (error) => new Error(`parse PORT error ${error.message}`));
 export function createObservabilityCommand() {
-    return {
-        command: "observe",
-        describe: "Start the observability server",
-        builder: (yargs) => {
-            return yargs
-                .option("host", {
-                type: "string",
-                describe: "Host to run the observability server on, use 0.0.0.0 to publicly expose the server",
-                default: "localhost",
-            })
-                .option("port", {
-                type: "number",
-                describe: "Port to run the observability server on",
-            });
-        },
-        handler: async (options) => {
-            const port = await detectPort(options.port || DEFAULT_PORT());
-            const dbUrl = getObservabilityDbPath();
-            console.log("Observability database path:", chalk.greenBright(dbUrl));
-            await startObservabilityCLIServer({ port, dbUrl });
-        },
-    };
+    return new Command("observe")
+        .description("Start the observability server")
+        .option("--host <host>", "Host to run the observability server on, use 0.0.0.0 to publicly expose the server", "localhost")
+        .option("--port <port>", "Port to run the observability server on", (s) => Number.parseInt(s))
+        .action(async (options) => {
+        const port = await detectPort(options.port || DEFAULT_PORT());
+        const dbUrl = getObservabilityDbPath();
+        console.log("Observability database path:", chalk.greenBright(dbUrl));
+        await startObservabilityCLIServer({ port, dbUrl });
+    })
+        .showHelpAfterError(true)
+        .showSuggestionAfterError(true);
 }

package/dist/commands/run.d.ts

@@ -1,7 +1,4 @@
-import type { CommandModule } from "yargs";
-export declare function createRunCommand({ aigneFilePath, }?: {
+import type { Command } from "commander";
+export declare function createRunCommand({ aigneFilePath }?: {
     aigneFilePath?: string;
-}): CommandModule;
-export declare function getLocalPackagePathFromUrl(url: string, { subdir }?: {
-    subdir?: string;
-}): string;
+}): Command;

package/dist/commands/run.js

@@ -12,109 +12,94 @@ import { isV1Package, toAIGNEPackage } from "../utils/agent-v1.js";
 import { downloadAndExtract } from "../utils/download.js";
 import { loadAIGNE } from "../utils/load-aigne.js";
 import { createRunAIGNECommand, parseAgentInputByCommander, runAgentWithAIGNE, } from "../utils/run-with-aigne.js";
-export function createRunCommand({ aigneFilePath, } = {}) {
-    return {
-        command: "run [path]",
-        describe: "Run AIGNE from the specified agent",
-        builder: (yargs) => {
-            return createRunAIGNECommand(yargs)
-                .positional("path", {
-                describe: "Path to the agents directory or URL to aigne project",
-                type: "string",
-                default: ".",
-                alias: ["url"],
-            })
-                .option("entry-agent", {
-                describe: "Name of the agent to run (defaults to the first agent found)",
-                type: "string",
-            })
-                .option("cache-dir", {
-                describe: "Directory to download the package to (defaults to the ~/.aigne/xxx)",
-                type: "string",
-            });
-        },
-        handler: async (argv) => {
-            const options = argv;
-            const path = aigneFilePath || options.path;
-            if (options.logLevel)
-                logger.level = options.logLevel;
-            const { cacheDir, dir } = prepareDirs(path, options);
-            const { aigne, agent } = await new Listr([
-                {
-                    title: "Prepare environment",
-                    task: (_, task) => {
-                        if (cacheDir) {
-                            return task.newListr([
-                                {
-                                    title: "Download package",
-                                    task: () => downloadPackage(path, cacheDir),
-                                },
-                                {
-                                    title: "Extract package",
-                                    task: () => extractPackage(cacheDir, dir),
-                                },
-                            ]);
-                        }
-                    },
-                },
-                {
-                    title: "Initialize AIGNE",
-                    task: async (ctx, task) => {
-                        // Load env files in the aigne directory
-                        config({ path: dir, silent: true });
-                        const aigne = await loadAIGNE(dir, { ...options, model: options.model || process.env.MODEL }, {
-                            inquirerPromptFn: (prompt) => {
-                                return task
-                                    .prompt(ListrInquirerPromptAdapter)
-                                    .run(select, prompt)
-                                    .then((res) => ({ [prompt.name]: res }));
+export function createRunCommand({ aigneFilePath } = {}) {
+    return createRunAIGNECommand()
+        .description("Run AIGNE from the specified agent")
+        .option("--url, --path <path_or_url>", "Path to the agents directory or URL to aigne project", ".")
+        .option("--entry-agent <entry-agent>", "Name of the agent to run (defaults to the first agent found)")
+        .option("--cache-dir <dir>", "Directory to download the package to (defaults to the ~/.aigne/xxx)")
+        .action(async (options) => {
+        const path = aigneFilePath || options.path;
+        if (options.logLevel)
+            logger.level = options.logLevel;
+        const { cacheDir, dir } = prepareDirs(path, options);
+        const { aigne, agent } = await new Listr([
+            {
+                title: "Prepare environment",
+                task: (_, task) => {
+                    if (cacheDir) {
+                        return task.newListr([
+                            {
+                                title: "Download package",
+                                task: () => downloadPackage(path, cacheDir),
+                            },
+                            {
+                                title: "Extract package",
+                                task: () => extractPackage(cacheDir, dir),
                             },
-                        });
-                        ctx.aigne = aigne;
-                    },
+                        ]);
+                    }
                 },
-                {
-                    task: (ctx) => {
-                        const { aigne } = ctx;
-                        assert(aigne);
-                        let entryAgent;
-                        if (options.entryAgent) {
-                            entryAgent = aigne.agents[options.entryAgent];
-                            if (!entryAgent) {
-                                throw new Error(`\
+            },
+            {
+                title: "Initialize AIGNE",
+                task: async (ctx, task) => {
+                    // Load env files in the aigne directory
+                    config({ path: dir, silent: true });
+                    const aigne = await loadAIGNE(dir, { ...options, model: options.model || process.env.MODEL }, {
+                        inquirerPromptFn: (prompt) => {
+                            return task
+                                .prompt(ListrInquirerPromptAdapter)
+                                .run(select, prompt)
+                                .then((res) => ({ [prompt.name]: res }));
+                        },
+                    });
+                    ctx.aigne = aigne;
+                },
+            },
+            {
+                task: (ctx) => {
+                    const { aigne } = ctx;
+                    assert(aigne);
+                    let entryAgent;
+                    if (options.entryAgent) {
+                        entryAgent = aigne.agents[options.entryAgent];
+                        if (!entryAgent) {
+                            throw new Error(`\
 Agent "${options.entryAgent}" not found in ${aigne.rootDir}
 
 Available agents:
 ${aigne.agents.map((agent) => `  - ${agent.name}`).join("\n")}
 `);
-                            }
-                        }
-                        else {
-                            entryAgent = aigne.agents[0];
-                            if (!entryAgent)
-                                throw new Error(`No any agent found in ${aigne.rootDir}`);
                         }
-                        ctx.agent = entryAgent;
-                    },
-                },
-            ], {
-                rendererOptions: {
-                    collapseSubtasks: false,
-                    showErrorMessage: false,
-                    timer: PRESET_TIMER,
+                    }
+                    else {
+                        entryAgent = aigne.agents[0];
+                        if (!entryAgent)
+                            throw new Error(`No any agent found in ${aigne.rootDir}`);
+                    }
+                    ctx.agent = entryAgent;
                 },
-            }).run();
-            assert(aigne);
-            assert(agent);
-            const input = await parseAgentInputByCommander(agent, options);
-            try {
-                await runAgentWithAIGNE(aigne, agent, { ...options, input });
-            }
-            finally {
-                await aigne.shutdown();
-            }
-        },
-    };
+            },
+        ], {
+            rendererOptions: {
+                collapseSubtasks: false,
+                showErrorMessage: false,
+                timer: PRESET_TIMER,
+            },
+        }).run();
+        assert(aigne);
+        assert(agent);
+        const input = await parseAgentInputByCommander(agent, options);
+        try {
+            await runAgentWithAIGNE(aigne, agent, { ...options, input });
+        }
+        finally {
+            await aigne.shutdown();
+        }
+    })
+        .showHelpAfterError(true)
+        .showSuggestionAfterError(true);
 }
 async function downloadPackage(url, cacheDir) {
     await rm(cacheDir, { recursive: true, force: true });
@@ -136,7 +121,7 @@ function prepareDirs(path, options) {
     if (!path.startsWith("http")) {
         dir = isAbsolute(path) ? path : resolve(process.cwd(), path);
     }
-    else if (options?.cacheDir) {
+    else if (options.cacheDir) {
         dir = isAbsolute(options.cacheDir)
             ? options.cacheDir
             : resolve(process.cwd(), options.cacheDir);
@@ -148,7 +133,7 @@ function prepareDirs(path, options) {
     }
     return { cacheDir, dir };
 }
-export function getLocalPackagePathFromUrl(url, { subdir } = {}) {
+function getLocalPackagePathFromUrl(url, { subdir } = {}) {
     const root = [homedir(), ".aigne", subdir].filter(isNonNullable);
     const u = new URL(url);
     return join(...root, u.hostname, u.pathname);

package/dist/commands/serve-mcp.d.ts

@@ -1,11 +1,4 @@
-import type { CommandModule } from "yargs";
-interface ServeMCPOptions {
-    path: string;
-    host: string;
-    port?: number;
-    pathname: string;
-}
-export declare function createServeMCPCommand({ aigneFilePath, }?: {
+import { Command } from "commander";
+export declare function createServeMCPCommand({ aigneFilePath }?: {
     aigneFilePath?: string;
-}): CommandModule<{}, ServeMCPOptions>;
-export {};
+}): Command;

package/dist/commands/serve-mcp.js

@@ -1,5 +1,6 @@
 import { isAbsolute, resolve } from "node:path";
 import { tryOrThrow } from "@aigne/core/utils/type-utils.js";
+import { Command } from "commander";
 import { loadAIGNE } from "../utils/load-aigne.js";
 import { serveMCPServer } from "../utils/serve-mcp.js";
 const DEFAULT_PORT = () => tryOrThrow(() => {
@@ -11,45 +12,26 @@ const DEFAULT_PORT = () => tryOrThrow(() => {
         throw new Error(`Invalid PORT: ${PORT}`);
     return port;
 }, (error) => new Error(`parse PORT error ${error.message}`));
-export function createServeMCPCommand({ aigneFilePath, } = {}) {
-    return {
-        command: "serve-mcp",
-        describe: "Serve the agents in the specified directory as a MCP server (streamable http)",
-        builder: (yargs) => {
-            return yargs
-                .option("path", {
-                describe: "Path to the agents directory or URL to aigne project",
-                type: "string",
-                default: ".",
-                alias: ["url"],
-            })
-                .option("host", {
-                describe: "Host to run the MCP server on, use 0.0.0.0 to publicly expose the server",
-                type: "string",
-                default: "localhost",
-            })
-                .option("port", {
-                describe: "Port to run the MCP server on",
-                type: "number",
-            })
-                .option("pathname", {
-                describe: "Pathname to the service",
-                type: "string",
-                default: "/mcp",
-            });
-        },
-        handler: async (options) => {
-            const path = aigneFilePath || options.path;
-            const absolutePath = isAbsolute(path) ? path : resolve(process.cwd(), path);
-            const port = options.port || DEFAULT_PORT();
-            const aigne = await loadAIGNE(absolutePath);
-            await serveMCPServer({
-                aigne,
-                host: options.host,
-                port,
-                pathname: options.pathname,
-            });
-            console.log(`MCP server is running on http://${options.host}:${port}${options.pathname}`);
-        },
-    };
+export function createServeMCPCommand({ aigneFilePath } = {}) {
+    return new Command("serve-mcp")
+        .description("Serve the agents in the specified directory as a MCP server (streamable http)")
+        .option("--url, --path <path_or_url>", "Path to the agents directory or URL to aigne project", ".")
+        .option("--host <host>", "Host to run the MCP server on, use 0.0.0.0 to publicly expose the server", "localhost")
+        .option("--port <port>", "Port to run the MCP server on", (s) => Number.parseInt(s))
+        .option("--pathname <pathname>", "Pathname to the service", "/mcp")
+        .action(async (options) => {
+        const path = aigneFilePath || options.path;
+        const absolutePath = isAbsolute(path) ? path : resolve(process.cwd(), path);
+        const port = options.port || DEFAULT_PORT();
+        const aigne = await loadAIGNE(absolutePath);
+        await serveMCPServer({
+            aigne,
+            host: options.host,
+            port,
+            pathname: options.pathname,
+        });
+        console.log(`MCP server is running on http://${options.host}:${port}${options.pathname}`);
+    })
+        .showHelpAfterError(true)
+        .showSuggestionAfterError(true);
 }

package/dist/commands/test.d.ts

@@ -1,8 +1,4 @@
-import type { CommandModule } from "yargs";
-interface TestOptions {
-    path: string;
-}
-export declare function createTestCommand({ aigneFilePath, }?: {
+import { Command } from "commander";
+export declare function createTestCommand({ aigneFilePath }?: {
     aigneFilePath?: string;
-}): CommandModule<{}, TestOptions>;
-export {};
+}): Command;

package/dist/commands/test.js

@@ -1,25 +1,19 @@
 import assert from "node:assert";
 import { spawnSync } from "node:child_process";
 import { isAbsolute, resolve } from "node:path";
+import { Command } from "commander";
 import { loadAIGNE } from "../utils/load-aigne.js";
-export function createTestCommand({ aigneFilePath, } = {}) {
-    return {
-        command: "test",
-        describe: "Run tests in the specified agents directory",
-        builder: (yargs) => {
-            return yargs.option("path", {
-                describe: "Path to the agents directory or URL to aigne project",
-                type: "string",
-                default: ".",
-                alias: ["url"],
-            });
-        },
-        handler: async (options) => {
-            const path = aigneFilePath || options.path;
-            const absolutePath = isAbsolute(path) ? path : resolve(process.cwd(), path);
-            const aigne = await loadAIGNE(absolutePath);
-            assert(aigne.rootDir);
-            spawnSync("node", ["--test"], { cwd: aigne.rootDir, stdio: "inherit" });
-        },
-    };
+export function createTestCommand({ aigneFilePath } = {}) {
+    return new Command("test")
+        .description("Run tests in the specified agents directory")
+        .option("--url, --path <path_or_url>", "Path to the agents directory or URL to aigne project", ".")
+        .action(async (options) => {
+        const path = aigneFilePath || options.path;
+        const absolutePath = isAbsolute(path) ? path : resolve(process.cwd(), path);
+        const aigne = await loadAIGNE(absolutePath);
+        assert(aigne.rootDir);
+        spawnSync("node", ["--test"], { cwd: aigne.rootDir, stdio: "inherit" });
+    })
+        .showHelpAfterError(true)
+        .showSuggestionAfterError(true);
 }

package/dist/utils/aigne-hub-user.d.ts

@@ -0,0 +1,16 @@
+export interface UserInfoResult {
+    user: Record<string, any>;
+    enableCredit: boolean;
+    creditBalance: {
+        balance: string;
+        total: string;
+        grantCount: number;
+        pendingCredit: string;
+    } | null;
+    paymentLink: string | null;
+    profileLink: string;
+}
+export declare function getUserInfo({ baseUrl, accessKey, }: {
+    baseUrl: string;
+    accessKey: string;
+}): Promise<UserInfoResult>;

package/dist/utils/aigne-hub-user.js

@@ -0,0 +1,12 @@
+import { joinURL } from "ufo";
+export async function getUserInfo({ baseUrl, accessKey, }) {
+    const response = await fetch(joinURL(baseUrl, "/api/user/info"), {
+        headers: {
+            Authorization: `Bearer ${accessKey}`,
+        },
+    });
+    if (!response.ok)
+        throw new Error(`Failed to fetch user info: ${response.statusText}`);
+    const data = await response.json();
+    return data;
+}

package/dist/utils/download.d.ts

@@ -1,3 +1 @@
-export declare function downloadAndExtract(url: string, dir: string, options?: {
-    strip?: number;
-}): Promise<void>;
+export declare function downloadAndExtract(url: string, dir: string): Promise<void>;

package/dist/utils/download.js

@@ -1,7 +1,7 @@
 import { Readable } from "node:stream";
 import { finished } from "node:stream/promises";
 import { x } from "tar";
-export async function downloadAndExtract(url, dir, options = {}) {
+export async function downloadAndExtract(url, dir) {
     const response = await fetch(url).catch((error) => {
         throw new Error(`Failed to download package from ${url}: ${error.message}`);
     });
@@ -12,7 +12,7 @@ export async function downloadAndExtract(url, dir, options = {}) {
         throw new Error(`Failed to download package from ${url}: Unexpected to get empty response`);
     }
     try {
-        await finished(Readable.fromWeb(response.body).pipe(x({ C: dir, ...options })));
+        await finished(Readable.fromWeb(response.body).pipe(x({ C: dir })));
     }
     catch (error) {
         error.message = `Failed to extract package from ${url}: ${error.message}`;

package/dist/utils/run-with-aigne.d.ts

@@ -1,7 +1,7 @@
 import { type Agent, AIGNE, type ChatModelOptions, type Message } from "@aigne/core";
 import { LogLevel } from "@aigne/core/utils/logger.js";
 import { type PromiseOrValue } from "@aigne/core/utils/type-utils.js";
-import type { Argv } from "yargs";
+import { Command } from "commander";
 import { type ChatLoopOptions } from "./run-chat-loop.js";
 export interface RunAIGNECommandOptions {
     chat?: boolean;
@@ -17,31 +17,7 @@ export interface RunAIGNECommandOptions {
     logLevel?: LogLevel;
     force?: boolean;
 }
-export declare const createRunAIGNECommand: (yargs: Argv) => Argv<{
-    chat: boolean;
-} & {
-    model: string | undefined;
-} & {
-    temperature: number | undefined;
-} & {
-    "top-p": number | undefined;
-} & {
-    "presence-penalty": number | undefined;
-} & {
-    "frequency-penalty": number | undefined;
-} & {
-    input: (string | number)[] | undefined;
-} & {
-    format: string | undefined;
-} & {
-    output: string | undefined;
-} & {
-    "output-key": string;
-} & {
-    force: boolean;
-} & {
-    "log-level": LogLevel;
-}>;
+export declare const createRunAIGNECommand: (name?: string) => Command;
 export declare function parseAgentInputByCommander(agent: Agent, options?: RunAIGNECommandOptions & {
     inputKey?: string;
     argv?: string[];

package/dist/utils/run-with-aigne.js

@@ -4,90 +4,67 @@ import { dirname, isAbsolute, join } from "node:path";
 import { isatty } from "node:tty";
 import { promisify } from "node:util";
 import { exists } from "@aigne/agent-library/utils/fs.js";
-import { AIAgent, AIGNE, DEFAULT_OUTPUT_KEY, readAllString, UserAgent, } from "@aigne/core";
+import { AIGNE, DEFAULT_OUTPUT_KEY, readAllString, UserAgent, } from "@aigne/core";
 import { loadModel } from "@aigne/core/loader/index.js";
 import { getLevelFromEnv, LogLevel, logger } from "@aigne/core/utils/logger.js";
-import { flat, isEmpty, tryOrThrow, } from "@aigne/core/utils/type-utils.js";
+import { isEmpty, isNonNullable, tryOrThrow, } from "@aigne/core/utils/type-utils.js";
 import chalk from "chalk";
+import { Command } from "commander";
 import { parse } from "yaml";
-import yargs from "yargs";
 import { ZodError, ZodObject, z } from "zod";
 import { availableModels } from "../constants.js";
 import { TerminalTracer } from "../tracer/terminal.js";
 import { DEFAULT_CHAT_INPUT_KEY, runChatLoopInTerminal, } from "./run-chat-loop.js";
-export const createRunAIGNECommand = (yargs) => yargs
-    .option("chat", {
-    describe: "Run chat loop in terminal",
-    type: "boolean",
-    default: false,
-})
-    .option("model", {
-    describe: `AI model to use in format 'provider[:model]' where model is optional. Examples: 'openai' or 'openai:gpt-4o-mini'. Available providers: ${availableModels()
-        .map((i) => i.name.toLowerCase().replace(/ChatModel$/i, ""))
-        .join(", ")} (default: openai)`,
-    type: "string",
-})
-    .option("temperature", {
-    describe: "Temperature for the model (controls randomness, higher values produce more random outputs). Range: 0.0-2.0",
-    type: "number",
-    coerce: customZodError("--temperature", (s) => z.coerce.number().min(0).max(2).parse(s)),
-})
-    .option("top-p", {
-    describe: "Top P (nucleus sampling) parameter for the model (controls diversity). Range: 0.0-1.0",
-    type: "number",
-    coerce: customZodError("--top-p", (s) => z.coerce.number().min(0).max(1).parse(s)),
-})
-    .option("presence-penalty", {
-    describe: "Presence penalty for the model (penalizes repeating the same tokens). Range: -2.0 to 2.0",
-    type: "number",
-    coerce: customZodError("--presence-penalty", (s) => z.coerce.number().min(-2).max(2).parse(s)),
-})
-    .option("frequency-penalty", {
-    describe: "Frequency penalty for the model (penalizes frequency of token usage). Range: -2.0 to 2.0",
-    type: "number",
-    coerce: customZodError("--frequency-penalty", (s) => z.coerce.number().min(-2).max(2).parse(s)),
-})
-    .option("input", {
-    describe: "Input to the agent, use @<file> to read from a file",
-    type: "array",
-    alias: "i",
-})
-    .option("format", {
-    describe: "Input format for the agent (available: text, json, yaml default: text)",
-    type: "string",
-})
-    .option("output", {
-    describe: "Output file to save the result (default: stdout)",
-    type: "string",
-    alias: "o",
-})
-    .option("output-key", {
-    describe: "Key in the result to save to the output file",
-    type: "string",
-    default: DEFAULT_OUTPUT_KEY,
-})
-    .option("force", {
-    describe: "Truncate the output file if it exists, and create directory if the output path is not exists",
-    type: "boolean",
-    default: false,
-})
-    .option("log-level", {
-    describe: `Log level for detailed debugging information. Values: ${Object.values(LogLevel).join(", ")}`,
-    type: "string",
-    default: getLevelFromEnv(logger.options.ns) || LogLevel.INFO,
-    coerce: customZodError("--log-level", (s) => z.nativeEnum(LogLevel).parse(s)),
-});
+export const createRunAIGNECommand = (name = "run") => new Command(name)
+    .allowUnknownOption(true)
+    .allowExcessArguments(true)
+    .description("Run agent with AIGNE in terminal")
+    .option("--chat", "Run chat loop in terminal", false)
+    .option("--model <provider[:model]>", `AI model to use in format 'provider[:model]' where model is optional. Examples: 'openai' or 'openai:gpt-4o-mini'. Available providers: ${availableModels()
+    .map((i) => i.name.toLowerCase().replace(/ChatModel$/i, ""))
+    .join(", ")} (default: openai)`)
+    .option("--temperature <temperature>", "Temperature for the model (controls randomness, higher values produce more random outputs). Range: 0.0-2.0", customZodError("--temperature", (s) => z.coerce.number().min(0).max(2).parse(s)))
+    .option("--top-p <top-p>", "Top P (nucleus sampling) parameter for the model (controls diversity). Range: 0.0-1.0", customZodError("--top-p", (s) => z.coerce.number().min(0).max(1).parse(s)))
+    .option("--presence-penalty <presence-penalty>", "Presence penalty for the model (penalizes repeating the same tokens). Range: -2.0 to 2.0", customZodError("--presence-penalty", (s) => z.coerce.number().min(-2).max(2).parse(s)))
+    .option("--frequency-penalty <frequency-penalty>", "Frequency penalty for the model (penalizes frequency of token usage). Range: -2.0 to 2.0", customZodError("--frequency-penalty", (s) => z.coerce.number().min(-2).max(2).parse(s)))
+    .option("--input -i <input...>", "Input to the agent, use @<file> to read from a file")
+    .option("--format <format>", "Input format for the agent (available: text, json, yaml default: text)")
+    .option("--output -o <output>", "Output file to save the result (default: stdout)")
+    .option("--output-key <output-key>", "Key in the result to save to the output file", DEFAULT_OUTPUT_KEY)
+    .option("--force", "Truncate the output file if it exists, and create directory if the output path is not exists", false)
+    .option("--log-level <level>", `Log level for detailed debugging information. Values: ${Object.values(LogLevel).join(", ")}`, customZodError("--log-level", (s) => z.nativeEnum(LogLevel).parse(s)), getLevelFromEnv(logger.options.ns) || LogLevel.INFO);
 export async function parseAgentInputByCommander(agent, options = {}) {
-    const inputSchemaShape = flat(agent instanceof AIAgent ? agent.inputKey : undefined, agent.inputSchema instanceof ZodObject ? Object.keys(agent.inputSchema.shape) : []);
-    const parsedInput = await yargs().parseAsync(options.argv ?? process.argv);
-    const input = Object.fromEntries(await Promise.all(inputSchemaShape.map(async (key) => {
-        const k = `input${key.charAt(0).toUpperCase()}${key.slice(1)}`;
-        let value = parsedInput[k];
-        if (typeof value === "string" && value.startsWith("@")) {
-            value = await readFile(value.slice(1), "utf8");
-        }
-        return [key, value];
-    })));
+    const cmd = new Command()
+        .description(`Run agent ${agent.name} with AIGNE`)
+        .allowUnknownOption(true)
+        .allowExcessArguments(true);
+    const inputSchemaShape = agent.inputSchema instanceof ZodObject ? Object.keys(agent.inputSchema.shape) : [];
+    for (const option of inputSchemaShape) {
+        cmd.option(`--input-${option} <${option}>`);
+    }
+    const input = await new Promise((resolve, reject) => {
+        cmd
+            .action(async (agentInputOptions) => {
+            try {
+                const input = Object.fromEntries((await Promise.all(Object.entries(agentInputOptions).map(async ([key, value]) => {
+                    let k = key.replace(/^input/, "");
+                    k = k.charAt(0).toLowerCase() + k.slice(1);
+                    if (!k)
+                        return null;
+                    if (typeof value === "string" && value.startsWith("@")) {
+                        value = await readFile(value.slice(1), "utf8");
+                    }
+                    return [k, value];
+                }))).filter(isNonNullable));
+                resolve(input);
+            }
+            catch (error) {
+                reject(error);
+            }
+        })
+            .parseAsync(options.argv ?? process.argv)
+            .catch((error) => reject(error));
+    });
     const rawInput = options.input ||
         (isatty(process.stdin.fd) || !(await stdinHasData())
             ? null
@@ -123,8 +100,10 @@ export const parseModelOption = (model) => {
     return { provider, name };
 };
 export async function runWithAIGNE(agentCreator, { argv = process.argv, chatLoopOptions, modelOptions, outputKey, } = {}) {
-    await yargs()
-        .command("$0", "Run an agent with AIGNE", (yargs) => createRunAIGNECommand(yargs), async (options) => {
+    await createRunAIGNECommand()
+        .showHelpAfterError(true)
+        .showSuggestionAfterError(true)
+        .action(async (options) => {
         if (options.logLevel) {
             logger.level = options.logLevel;
         }
@@ -155,8 +134,6 @@ export async function runWithAIGNE(agentCreator, { argv = process.argv, chatLoop
             await aigne.shutdown();
         }
     })
-        .alias("h", "help")
-        .alias("v", "version")
         .parseAsync(argv)
         .catch((error) => {
         console.error(`${chalk.red("Error:")} ${error.message}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/cli",
-  "version": "1.26.1-1",
+  "version": "1.27.0",
   "description": "cli for AIGNE framework",
   "publishConfig": {
     "access": "public"
@@ -44,7 +44,6 @@
   "dependencies": {
     "@aigne/listr2": "^1.0.10",
     "@aigne/marked-terminal": "^7.3.2",
-    "@blocklet/aigne-hub": "^0.2.17",
     "@inquirer/prompts": "^7.6.0",
     "@inquirer/type": "^3.0.8",
     "@listr2/prompt-adapter-inquirer": "^3.0.1",
@@ -52,6 +51,7 @@
     "@ocap/mcrypto": "^1.21.0",
     "@smithy/node-http-handler": "^4.1.0",
     "chalk": "^5.4.1",
+    "commander": "^14.0.0",
     "crypto": "^1.0.1",
     "detect-port": "^2.1.0",
     "dotenv-flow": "^4.1.0",
@@ -69,22 +69,21 @@
     "tar": "^7.4.3",
     "wrap-ansi": "^9.0.0",
     "yaml": "^2.8.0",
-    "yargs": "^18.0.0",
     "zod": "^3.25.67",
+    "@aigne/agent-library": "^1.21.6",
+    "@aigne/aigne-hub": "^0.3.0",
     "@aigne/agentic-memory": "^1.0.6",
-    "@aigne/aigne-hub": "^0.2.2",
     "@aigne/anthropic": "^0.10.2",
-    "@aigne/agent-library": "^1.21.6",
     "@aigne/bedrock": "^0.8.6",
-    "@aigne/core": "^1.39.0",
     "@aigne/deepseek": "^0.7.6",
     "@aigne/default-memory": "^1.0.6",
+    "@aigne/gemini": "^0.8.6",
     "@aigne/observability-api": "^0.8.2",
-    "@aigne/ollama": "^0.7.6",
     "@aigne/open-router": "^0.7.6",
-    "@aigne/xai": "^0.7.6",
-    "@aigne/gemini": "^0.8.6",
-    "@aigne/openai": "^0.10.6"
+    "@aigne/ollama": "^0.7.6",
+    "@aigne/core": "^1.39.0",
+    "@aigne/openai": "^0.10.6",
+    "@aigne/xai": "^0.7.6"
   },
   "devDependencies": {
     "@types/archiver": "^6.0.3",
@@ -93,7 +92,6 @@
     "@types/glob": "^9.0.0",
     "@types/gradient-string": "^1.1.6",
     "@types/node": "^24.0.12",
-    "@types/yargs": "^17.0.33",
     "archiver": "^7.0.1",
     "hono": "4.8.4",
     "npm-run-all": "^4.1.5",

package/dist/commands/app.d.ts

@@ -1,2 +0,0 @@
-import type { CommandModule } from "yargs";
-export declare function createAppCommands(): CommandModule[];

package/dist/commands/app.js

@@ -1,98 +0,0 @@
-import assert from "node:assert";
-import { spawnSync } from "node:child_process";
-import { mkdir, readFile, stat } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { AIGNE } from "@aigne/core";
-import { joinURL } from "ufo";
-import { ZodObject, ZodString } from "zod";
-import { availableModels } from "../constants.js";
-import { downloadAndExtract } from "../utils/download.js";
-import { runAgentWithAIGNE } from "../utils/run-with-aigne.js";
-const NPM_PACKAGE_CACHE_TIME_MS = 1000 * 60 * 60 * 24; // 1 day
-export function createAppCommands() {
-    return [
-        {
-            command: "doc-smith",
-            describe: "Generate professional documents by doc-smith",
-            aliases: ["docsmith", "doc"],
-            builder: async (yargs) => {
-                const aigne = await loadApplication({ name: "doc-smith" });
-                for (const agent of aigne.agents) {
-                    yargs.command(agent.name, agent.description || "", (yargs) => {
-                        const options = Object.entries(agent.inputSchema instanceof ZodObject ? agent.inputSchema.shape : {});
-                        for (const [option, config] of options) {
-                            yargs.option(option, {
-                                // TODO: support more types
-                                type: config instanceof ZodString ? "string" : "string",
-                                description: config.description,
-                            });
-                            if (!(config.isNullable() || config.isOptional())) {
-                                yargs.demandOption(option);
-                            }
-                        }
-                    }, async (argv) => {
-                        try {
-                            await runAgentWithAIGNE(aigne, agent, { input: argv });
-                        }
-                        finally {
-                            await aigne.shutdown();
-                        }
-                    });
-                }
-                yargs.version('hello world');
-                return yargs.demandCommand();
-            },
-            handler: () => { },
-        },
-    ];
-}
-async function loadApplication({ name }) {
-    const info = await shouldDownloadNewVersion(name);
-    if (info.shouldDownload) {
-        assert(info.url, "Package URL should be defined when downloading");
-        // TODO: clean up old versions
-        await mkdir(info.dir, { recursive: true });
-        await downloadAndExtract(info.url.toString(), info.dir, { strip: 1 });
-        spawnSync("npm", ["install", "--omit", "dev"], { cwd: info.dir, stdio: "inherit" });
-    }
-    return AIGNE.load(info.dir, { models: availableModels() });
-}
-async function shouldDownloadNewVersion(name, { cacheTimeMs = NPM_PACKAGE_CACHE_TIME_MS } = {}) {
-    const nameWithOrg = `@aigne/${name}`;
-    const dir = join(homedir(), ".aigne", "registry.npmjs.org", nameWithOrg);
-    const s = await stat(join(dir, "package.json")).catch((error) => {
-        if (error.code === "ENOENT") {
-            return null;
-        }
-        throw error;
-    });
-    if (!s)
-        return {
-            shouldDownload: true,
-            dir,
-            url: await getNpmTgzInfo(nameWithOrg).then((info) => info.tarballUrl),
-        };
-    const lastModified = s.mtimeMs;
-    const now = Date.now();
-    if (now - lastModified > cacheTimeMs) {
-        const version = JSON.parse(await readFile(join(dir, "package.json"), "utf-8")).version;
-        const latest = await getNpmTgzInfo(`@aigne/${name}`);
-        if (version !== latest.version) {
-            return { shouldDownload: true, url: latest.tarballUrl, dir };
-        }
-    }
-    return { shouldDownload: false, dir };
-}
-async function getNpmTgzInfo(name) {
-    const res = await fetch(joinURL("https://registry.npmjs.org", name));
-    if (!res.ok)
-        throw new Error(`Failed to fetch package info for ${name}: ${res.statusText}`);
-    const data = await res.json();
-    const latestVersion = data["dist-tags"].latest;
-    const tarballUrl = data.versions[latestVersion].dist.tarball;
-    return {
-        version: latestVersion,
-        tarballUrl,
-    };
-}