@aigne/cli 1.33.1 → 1.35.0

package/CHANGELOG.md

@@ -1,5 +1,57 @@
 # Changelog
 
+## [1.35.0](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.34.1...cli-v1.35.0) (2025-08-13)
+
+
+### Features
+
+* **cli:** support aigne hub commond ([#352](https://github.com/AIGNE-io/aigne-framework/issues/352)) ([0341f19](https://github.com/AIGNE-io/aigne-framework/commit/0341f190229b42c5d2ab8a8616597359f35543a7))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/aigne-hub bumped to 0.5.0
+
+## [1.34.1](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.34.0...cli-v1.34.1) (2025-08-12)
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/agent-library bumped to 1.21.19
+    * @aigne/agentic-memory bumped to 1.0.19
+    * @aigne/aigne-hub bumped to 0.4.10
+    * @aigne/core bumped to 1.49.1
+    * @aigne/default-memory bumped to 1.1.1
+    * @aigne/openai bumped to 0.11.1
+
+## [1.34.0](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.33.1...cli-v1.34.0) (2025-08-12)
+
+
+### Features
+
+* **cli:** add retry functionality and improve error handling for AIGNE Hub ([#348](https://github.com/AIGNE-io/aigne-framework/issues/348)) ([672c93a](https://github.com/AIGNE-io/aigne-framework/commit/672c93abbba8b4b234f6d810536ff4b603a97e1e))
+
+
+### Bug Fixes
+
+* **core:** examples cases that failed when using aigne-hub ([#337](https://github.com/AIGNE-io/aigne-framework/issues/337)) ([0d4a31c](https://github.com/AIGNE-io/aigne-framework/commit/0d4a31c24d9e7d26f00d1accb80719d9ad79a4c6))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/agent-library bumped to 1.21.18
+    * @aigne/agentic-memory bumped to 1.0.18
+    * @aigne/aigne-hub bumped to 0.4.9
+    * @aigne/core bumped to 1.49.0
+    * @aigne/default-memory bumped to 1.1.0
+    * @aigne/openai bumped to 0.11.0
+
 ## [1.33.1](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.33.0...cli-v1.33.1) (2025-08-12)
 
 

package/dist/cli.js

@@ -4,6 +4,7 @@ import chalk from "chalk";
 import { config } from "dotenv-flow";
 import { hideBin } from "yargs/helpers";
 import { createAIGNECommand } from "./commands/aigne.js";
+import { highlightUrl } from "./utils/string-utils.js";
 config({ silent: true });
 function getAIGNEFilePath() {
     let file = process.argv[2];
@@ -27,6 +28,6 @@ export default createAIGNECommand({ aigneFilePath })
     .parseAsync(hideBin([...process.argv.slice(0, 2), ...process.argv.slice(aigneFilePath ? 3 : 2)]))
     .catch((error) => {
     console.log(""); // Add an empty line for better readability
-    console.error(`${chalk.red("Error:")} ${error.message.replace(/https?:\/\/[^\s]+/g, (url) => chalk.cyan(url))}`);
+    console.error(`${chalk.red("Error:")} ${highlightUrl(error.message)}`);
     process.exit(1);
 });

package/dist/commands/aigne.js

@@ -3,8 +3,8 @@ import yargs from "yargs";
 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 { createHubCommand } from "./hub.js";
 import { createObservabilityCommand } from "./observe.js";
 import { createRunCommand } from "./run.js";
 import { createServeMCPCommand } from "./serve-mcp.js";
@@ -21,8 +21,8 @@ export function createAIGNECommand(options) {
         .command(createCreateCommand())
         .command(createServeMCPCommand(options))
         .command(createObservabilityCommand())
-        .command(createConnectCommand())
         .command(createAppCommands())
+        .command(createHubCommand())
         .demandCommand()
         .alias("help", "h")
         .alias("version", "v")

package/dist/commands/app.js

@@ -130,7 +130,10 @@ function innerZodType(type) {
     return type;
 }
 export async function invokeCLIAgentFromDir(options) {
-    const aigne = await loadAIGNE(options.dir, { model: options.input.model });
+    const aigne = await loadAIGNE({
+        path: options.dir,
+        options: { model: options.input.model },
+    });
     try {
         const agent = aigne.cli.agents[options.agent];
         assert(agent, `Agent ${options.agent} not found in ${options.dir}`);

package/dist/commands/hub.d.ts

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

package/dist/commands/hub.js

@@ -0,0 +1,271 @@
+import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import { AIGNE_ENV_FILE, AIGNE_HUB_URL, connectToAIGNEHub, isTest } from "@aigne/aigne-hub";
+import chalk from "chalk";
+import Table from "cli-table3";
+import inquirer from "inquirer";
+import { parse, stringify } from "yaml";
+import { getUserInfo } from "../utils/aigne-hub-user.js";
+const formatNumber = (balance) => {
+    const balanceNum = String(balance).split(".")[0];
+    return chalk.yellow((balanceNum || "").replace(/\B(?=(\d{3})+(?!\d))/g, ","));
+};
+function printHubStatus(data) {
+    const divider = "─".repeat(46);
+    console.log(chalk.bold("AIGNE Hub Connection"));
+    console.log(chalk.gray(divider));
+    console.log(`${chalk.bold("Hub:".padEnd(10))} ${data.hub}`);
+    console.log(`${chalk.bold("Status:".padEnd(10))} ${data.status === "Connected"
+        ? chalk.green(`${data.status} ✅`)
+        : chalk.red(`${data.status} ❌`)}`);
+    console.log("");
+    console.log(chalk.bold("User:"));
+    console.log(`  ${chalk.bold("Name:".padEnd(8))} ${data.user.name}`);
+    console.log(`  ${chalk.bold("DID:".padEnd(8))} ${data.user.did}`);
+    console.log(`  ${chalk.bold("Email:".padEnd(8))} ${data.user.email}`);
+    console.log("");
+    console.log(chalk.bold("Credits:"));
+    console.log(`  ${chalk.bold("Used:".padEnd(8))} ${data.credits.used.toLocaleString()}`);
+    console.log(`  ${chalk.bold("Total:".padEnd(8))} ${data.credits.total.toLocaleString()}`);
+    console.log("");
+    console.log(chalk.bold("Links:"));
+    console.log(`  ${chalk.bold("Payment:".padEnd(8))} ${data.links.payment}`);
+    console.log(`  ${chalk.bold("Profile:".padEnd(8))} ${data.links.profile}`);
+}
+async function getHubs() {
+    if (!existsSync(AIGNE_ENV_FILE)) {
+        return [];
+    }
+    try {
+        const data = await readFile(AIGNE_ENV_FILE, "utf8");
+        const envs = parse(data);
+        const statusList = [];
+        for (const [host, config] of Object.entries(envs)) {
+            if (host !== "default") {
+                statusList.push({
+                    host,
+                    apiUrl: config.AIGNE_HUB_API_URL,
+                    apiKey: config.AIGNE_HUB_API_KEY,
+                });
+            }
+        }
+        return statusList;
+    }
+    catch {
+        return [];
+    }
+}
+const getDefaultHub = async () => {
+    const envs = parse(await readFile(AIGNE_ENV_FILE, "utf8").catch(() => stringify({})));
+    return envs?.default?.AIGNE_HUB_API_URL || AIGNE_HUB_URL;
+};
+async function formatHubsList(statusList) {
+    if (statusList?.length === 0) {
+        console.log(chalk.yellow("No AIGNE Hub configured."));
+        console.log("Use 'aigne hub connect' to connect to a hub.");
+        return;
+    }
+    const defaultHub = await getDefaultHub();
+    const table = new Table({
+        head: ["URL", "ACTIVE", "STATUS"],
+        colWidths: [50, 10, 20],
+        style: {
+            head: ["cyan"],
+            border: ["grey"],
+        },
+    });
+    console.log(chalk.blue("AIGNE Hubs:\n"));
+    for (const status of statusList) {
+        const isConnected = new URL(status.apiUrl).origin === new URL(defaultHub).origin;
+        table.push([
+            status.apiUrl,
+            isConnected ? "*" : "-",
+            isConnected ? "Connected" : "Not connected",
+        ]);
+    }
+    console.log(table.toString());
+}
+export function createHubCommand() {
+    return {
+        command: "hub <command>",
+        describe: "Manage AIGNE Hub connections",
+        builder: (yargs) => yargs
+            .command(["list", "ls"], "List all connected AIGNE Hubs", listHubs)
+            .command("connect", "Connect to an AIGNE Hub", connectHub)
+            .command("use", "Switch to a different AIGNE Hub", useHub)
+            .command(["status", "st"], "Show current active hub", showStatus)
+            .command(["remove", "rm"], "Remove a connected hub", removeHub)
+            .command(["info", "i"], "Show details of a connected hub", showInfo)
+            .demandCommand(1, "Please provide a valid hub command"),
+        handler: () => { },
+    };
+}
+const listHubs = async () => {
+    const list = await getHubs();
+    await formatHubsList(list);
+};
+async function connectHub() {
+    const defaultUrl = "https://hub.aigne.io";
+    const { isOfficial } = await inquirer.prompt({
+        type: "select",
+        name: "isOfficial",
+        message: `Choose a hub to connect:`,
+        choices: [
+            { name: `Official Hub (${defaultUrl})`, value: true },
+            { name: `Custom Hub URL`, value: false },
+        ],
+        default: true,
+    });
+    let currentUrl = defaultUrl;
+    if (!isOfficial) {
+        const { customUrl } = await inquirer.prompt({
+            type: "input",
+            name: "customUrl",
+            message: "Enter the URL of your AIGNE Hub:",
+            validate: validateUrl,
+        });
+        currentUrl = customUrl;
+    }
+    await saveAndConnect(currentUrl);
+}
+async function useHub() {
+    const hubs = await getHubs();
+    if (!hubs.length) {
+        console.log(chalk.yellow("No AIGNE Hub configured."));
+        return;
+    }
+    const { hubApiKey } = await inquirer.prompt({
+        type: "select",
+        name: "hubApiKey",
+        message: `Choose a hub to switch to:`,
+        choices: hubs.map((h) => ({
+            name: new URL(h.apiUrl).origin,
+            value: h.apiUrl,
+        })),
+    });
+    await setDefaultHub(hubApiKey);
+}
+async function showStatus() {
+    const active = await getDefaultHub();
+    if (!active) {
+        console.log(chalk.red("No active hub."));
+        return;
+    }
+    console.log(`Active hub: ${active} - online`);
+}
+async function removeHub() {
+    const hubs = await getHubs();
+    if (!hubs.length) {
+        console.log(chalk.yellow("No AIGNE Hub configured."));
+        return;
+    }
+    const { hubApiKey } = await inquirer.prompt({
+        type: "select",
+        name: "hubApiKey",
+        message: `Choose a hub to remove:`,
+        choices: hubs.map((h) => ({
+            name: new URL(h.apiUrl).origin,
+            value: h.apiUrl,
+        })),
+    });
+    await deleteHub(hubApiKey);
+}
+async function showInfo() {
+    const hubs = await getHubs();
+    if (!hubs.length) {
+        console.log(chalk.yellow("No AIGNE Hub configured."));
+        return;
+    }
+    const { hubApiKey } = await inquirer.prompt({
+        type: "select",
+        name: "hubApiKey",
+        message: `Choose a hub to view info:`,
+        choices: hubs.map((h) => ({
+            name: new URL(h.apiUrl).origin,
+            value: h.apiUrl,
+        })),
+    });
+    await printHubDetails(hubApiKey);
+}
+function validateUrl(input) {
+    try {
+        const url = new URL(input);
+        return url.protocol.startsWith("http") ? true : "Must be http or https";
+    }
+    catch {
+        return "Invalid URL";
+    }
+}
+async function saveAndConnect(url) {
+    const envs = parse(await readFile(AIGNE_ENV_FILE, "utf8").catch(() => stringify({})));
+    const host = new URL(url).host;
+    if (envs[host]) {
+        await setDefaultHub(envs[host]?.AIGNE_HUB_API_URL || "");
+        console.log(chalk.green(`✓ Hub ${envs[host]?.AIGNE_HUB_API_URL} connected successfully.`));
+        return;
+    }
+    try {
+        if (isTest) {
+            writeFile(AIGNE_ENV_FILE, stringify({
+                "hub.aigne.io": {
+                    AIGNE_HUB_API_KEY: "test-key",
+                    AIGNE_HUB_API_URL: "https://hub.aigne.io/ai-kit",
+                },
+                default: {
+                    AIGNE_HUB_API_URL: "https://hub.aigne.io/ai-kit",
+                },
+            }));
+            return;
+        }
+        await connectToAIGNEHub(url);
+        console.log(chalk.green(`✓ Hub ${url} connected successfully.`));
+    }
+    catch (error) {
+        console.error(chalk.red("✗ Failed to connect:"), error.message);
+    }
+}
+async function setDefaultHub(url) {
+    const envs = parse(await readFile(AIGNE_ENV_FILE, "utf8").catch(() => stringify({})));
+    const host = new URL(url).host;
+    if (!envs[host]) {
+        console.error(chalk.red("✗ Hub not found"));
+        return;
+    }
+    await writeFile(AIGNE_ENV_FILE, stringify({ ...envs, default: { AIGNE_HUB_API_URL: envs[host]?.AIGNE_HUB_API_URL } }));
+    console.log(chalk.green(`✓ Switched active hub to ${url}`));
+}
+async function deleteHub(url) {
+    const envs = parse(await readFile(AIGNE_ENV_FILE, "utf8").catch(() => stringify({})));
+    const host = new URL(url).host;
+    delete envs[host];
+    if (envs.default?.AIGNE_HUB_API_URL && new URL(envs.default?.AIGNE_HUB_API_URL).host === host) {
+        delete envs.default;
+    }
+    await writeFile(AIGNE_ENV_FILE, stringify(envs));
+    console.log(chalk.green(`✓ Hub ${url} removed`));
+}
+async function printHubDetails(url) {
+    const envs = parse(await readFile(AIGNE_ENV_FILE, "utf8").catch(() => stringify({})));
+    const host = new URL(url).host;
+    const userInfo = await getUserInfo({
+        baseUrl: envs[host]?.AIGNE_HUB_API_URL || "",
+        apiKey: envs[host]?.AIGNE_HUB_API_KEY || "",
+    }).catch(() => null);
+    printHubStatus({
+        hub: url,
+        status: userInfo ? "Connected" : "Not connected",
+        user: {
+            name: userInfo?.user.fullName || "",
+            did: userInfo?.user.did || "",
+            email: userInfo?.user.email || "",
+        },
+        credits: {
+            used: formatNumber(userInfo?.creditBalance?.balance || "0"),
+            total: formatNumber(userInfo?.creditBalance?.total || "0"),
+        },
+        links: {
+            payment: userInfo?.paymentLink || "",
+            profile: userInfo?.profileLink || "",
+        },
+    });
+}

package/dist/commands/run.js

@@ -44,6 +44,7 @@ export function createRunCommand({ aigneFilePath, } = {}) {
             if (options.logLevel)
                 logger.level = options.logLevel;
             const { cacheDir, dir } = prepareDirs(path, options);
+            const originalLog = {};
             const { aigne, agent } = await new Listr([
                 {
                     title: "Prepare environment",
@@ -67,24 +68,37 @@ export function createRunCommand({ aigneFilePath, } = {}) {
                     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,
-                            aigneHubUrl: options?.aigneHubUrl,
-                        }, {
-                            inquirerPromptFn: (prompt) => {
-                                if (prompt.type === "input") {
+                        ctx.logs = [];
+                        for (const method of ["debug", "log", "info", "warn", "error"]) {
+                            originalLog[method] = console[method];
+                            console[method] = (...args) => {
+                                ctx.logs.push(...args);
+                                task.output = args.join(" ");
+                            };
+                        }
+                        const aigne = await loadAIGNE({
+                            path: dir,
+                            options: {
+                                ...options,
+                                model: options.model || process.env.MODEL,
+                                aigneHubUrl: options?.aigneHubUrl,
+                            },
+                            actionOptions: {
+                                inquirerPromptFn: (prompt) => {
+                                    if (prompt.type === "input") {
+                                        return task
+                                            .prompt(ListrInquirerPromptAdapter)
+                                            .run(inputInquirer, prompt)
+                                            .then((res) => ({ [prompt.name]: res }));
+                                    }
                                     return task
                                         .prompt(ListrInquirerPromptAdapter)
-                                        .run(inputInquirer, prompt)
+                                        .run(selectInquirer, prompt)
                                         .then((res) => ({ [prompt.name]: res }));
-                                }
-                                return task
-                                    .prompt(ListrInquirerPromptAdapter)
-                                    .run(selectInquirer, prompt)
-                                    .then((res) => ({ [prompt.name]: res }));
+                                },
                             },
                         });
+                        Object.assign(console, originalLog);
                         ctx.aigne = aigne;
                     },
                 },
@@ -118,7 +132,12 @@ ${aigne.agents.map((agent) => `  - ${agent.name}`).join("\n")}
                     showErrorMessage: false,
                     timer: PRESET_TIMER,
                 },
-            }).run();
+            })
+                .run()
+                .then((ctx) => {
+                ctx.logs.forEach((log) => console.log(log));
+                return ctx;
+            });
             assert(aigne);
             assert(agent);
             const input = await parseAgentInputByCommander(agent, options);

package/dist/commands/serve-mcp.js

@@ -51,7 +51,10 @@ export function createServeMCPCommand({ aigneFilePath, } = {}) {
 }
 export async function serveMCPServerFromDir(options) {
     const port = options.port || DEFAULT_PORT();
-    const aigne = await loadAIGNE(options.dir, { aigneHubUrl: options.aigneHubUrl });
+    const aigne = await loadAIGNE({
+        path: options.dir,
+        options: { aigneHubUrl: options.aigneHubUrl },
+    });
     await serveMCPServer({
         aigne,
         host: options.host,

package/dist/commands/test.js

@@ -22,7 +22,10 @@ export function createTestCommand({ aigneFilePath, } = {}) {
         handler: async (options) => {
             const path = aigneFilePath || options.path;
             const absolutePath = isAbsolute(path) ? path : resolve(process.cwd(), path);
-            const aigne = await loadAIGNE(absolutePath, { aigneHubUrl: options?.aigneHubUrl });
+            const aigne = await loadAIGNE({
+                path: absolutePath,
+                options: { aigneHubUrl: options?.aigneHubUrl },
+            });
             assert(aigne.rootDir);
             spawnSync("node", ["--test"], { cwd: aigne.rootDir, stdio: "inherit" });
         },

package/dist/tracer/terminal.d.ts

@@ -25,7 +25,7 @@ export declare class TerminalTracer {
         usage?: boolean;
         time?: boolean;
         input: Message;
-    }): string;
+    }): Promise<string>;
     private marked;
     get outputKey(): string;
     formatRequest(agent: Agent, _context: Context, m?: Message, { running }?: {

package/dist/tracer/terminal.js

@@ -10,6 +10,7 @@ import * as prompts from "@inquirer/prompts";
 import chalk from "chalk";
 import { Marked } from "marked";
 import { AIGNEListr, AIGNEListrRenderer } from "../utils/listr.js";
+import { highlightUrl } from "../utils/string-utils.js";
 import { parseDuration } from "../utils/time.js";
 export class TerminalTracer {
     context;
@@ -28,6 +29,24 @@ export class TerminalTracer {
                 : undefined,
             formatResult: (result, options) => [this.formatResult(agent, context, result, options)].filter(Boolean),
         }, [], { concurrent: true });
+        const proxiedPrompts = new Proxy({}, {
+            get: (_target, prop) => {
+                // biome-ignore lint/performance/noDynamicNamespaceImportAccess: we need to access prompts dynamically
+                const method = prompts[prop];
+                if (typeof method !== "function")
+                    return undefined;
+                return async (config) => {
+                    const renderer = listr["renderer"] instanceof AIGNEListrRenderer ? listr["renderer"] : undefined;
+                    await renderer?.pause();
+                    try {
+                        return await method({ ...config });
+                    }
+                    finally {
+                        await renderer?.resume();
+                    }
+                };
+            },
+        });
         const onStart = async ({ context, agent, ...event }) => {
             if (agent instanceof UserAgent)
                 return;
@@ -40,7 +59,7 @@ export class TerminalTracer {
             };
             this.tasks[contextId] = task;
             const listrTask = {
-                title: this.formatTaskTitle(agent, { ...event }),
+                title: await this.formatTaskTitle(agent, { ...event }),
                 task: (ctx, taskWrapper) => {
                     const subtask = taskWrapper.newListr([{ task: () => task.promise }]);
                     task.listr.resolve({ subtask, taskWrapper, ctx });
@@ -61,28 +80,7 @@ export class TerminalTracer {
             else {
                 listr.add(listrTask);
             }
-            return {
-                options: {
-                    prompts: new Proxy({}, {
-                        get: (_target, prop) => {
-                            // biome-ignore lint/performance/noDynamicNamespaceImportAccess: we need to access prompts dynamically
-                            const method = prompts[prop];
-                            if (typeof method !== "function")
-                                return undefined;
-                            return async (config) => {
-                                const renderer = listr["renderer"] instanceof AIGNEListrRenderer ? listr["renderer"] : undefined;
-                                await renderer?.pause();
-                                try {
-                                    return await method({ ...config });
-                                }
-                                finally {
-                                    await renderer?.resume();
-                                }
-                            };
-                        },
-                    }),
-                },
-            };
+            return { options: { prompts: proxiedPrompts } };
         };
         const onSuccess = async ({ context, agent, output, ...event }) => {
             const contextId = context.id;
@@ -99,20 +97,49 @@ export class TerminalTracer {
                 if (model)
                     task.extraTitleMetadata.model = model;
             }
-            taskWrapper.title = this.formatTaskTitle(agent, { ...event, task, usage: true, time: true });
+            taskWrapper.title = await this.formatTaskTitle(agent, {
+                ...event,
+                task,
+                usage: true,
+                time: true,
+            });
             if (!parentContextId || !this.tasks[parentContextId]) {
                 Object.assign(ctx, output);
             }
             task.resolve();
         };
         const onError = async ({ context, agent, error, ...event }) => {
+            if ("type" in error && error.type === "NOT_ENOUGH") {
+                const retry = await proxiedPrompts.select({
+                    message: highlightUrl(error.message),
+                    choices: [
+                        {
+                            name: "I have bought some credits, try again",
+                            value: "retry",
+                        },
+                        {
+                            name: "Exit",
+                            value: "exit",
+                        },
+                    ],
+                });
+                console.log("");
+                if (retry === "retry") {
+                    return { retry: true };
+                }
+            }
             const contextId = context.id;
             const task = this.tasks[contextId];
             if (!task)
                 return;
             task.endTime = Date.now();
             const { taskWrapper } = await task.listr.promise;
-            taskWrapper.title = this.formatTaskTitle(agent, { ...event, task, usage: true, time: true });
+            taskWrapper.title = await this.formatTaskTitle(agent, {
+                ...event,
+                task,
+                usage: true,
+                time: true,
+            });
             task.reject(error);
         };
         const result = await listr.run(() => context.invoke(agent, input, {
@@ -145,10 +172,10 @@ export class TerminalTracer {
         const duration = endTime - startTime;
         return chalk.grey(`[${parseDuration(duration)}]`);
     }
-    formatTaskTitle(agent, { task, usage, time, input }) {
+    async formatTaskTitle(agent, { task, usage, time, input }) {
         let title = agent.name;
         if (agent.taskTitle) {
-            title += ` ${chalk.cyan(agent.renderTaskTitle(input))}`;
+            title += ` ${chalk.cyan(await agent.renderTaskTitle(input))}`;
         }
         if (usage && task?.usage)
             title += ` ${this.formatTokenUsage(task.usage, task.extraTitleMetadata)}`;

package/dist/utils/load-aigne.d.ts

@@ -1,72 +1,18 @@
-import { availableModels } from "@aigne/aigne-hub";
-import { AIGNE } from "@aigne/core";
-import inquirer from "inquirer";
-import { type RunAIGNECommandOptions } from "./run-with-aigne.js";
-export declare const decrypt: (m: string, s: string, i: string) => string;
-export declare const encrypt: (m: string, s: string, i: string) => string;
-export declare const encodeEncryptionKey: (key: string) => string;
-export declare const decodeEncryptionKey: (str: string) => Uint8Array<ArrayBuffer>;
-export declare const AIGNE_ENV_FILE: string;
+import type { LoadCredentialOptions, Model } from "@aigne/aigne-hub";
+import { AIGNE, type ChatModelOptions } from "@aigne/core";
+import type { RunAIGNECommandOptions } from "./run-with-aigne.js";
 export interface RunOptions extends RunAIGNECommandOptions {
     path: string;
     entryAgent?: string;
     cacheDir?: string;
     aigneHubUrl?: string;
 }
-type FetchResult = {
-    accessKeyId: string;
-    accessKeySecret: string;
-};
-export declare const fetchConfigs: ({ connectUrl, sessionId, fetchInterval, fetchTimeout, }: {
-    connectUrl: string;
-    sessionId: string;
-    fetchInterval: number;
-    fetchTimeout: number;
-}) => Promise<any>;
-declare function baseWrapSpinner(_: string, waiting: () => Promise<FetchResult>): Promise<FetchResult>;
-interface CreateConnectOptions {
-    connectUrl: string;
-    openPage?: (url: string) => void;
-    fetchInterval?: number;
-    retry?: number;
-    source?: string;
-    connectAction?: string;
-    appName?: string;
-    appLogo?: string;
-    wrapSpinner?: typeof baseWrapSpinner;
-    prettyUrl?: (url: string) => string;
-    closeOnSuccess?: boolean;
-    intervalFetchConfig?: (options: {
-        sessionId: string;
-        fetchInterval: number;
-        fetchTimeout: number;
-    }) => Promise<FetchResult>;
-}
-export declare function createConnect({ connectUrl, openPage, fetchInterval, retry, source, connectAction, wrapSpinner, closeOnSuccess, intervalFetchConfig, appName, appLogo, }: CreateConnectOptions): Promise<FetchResult>;
-export declare const DEFAULT_URL = "https://hub.aigne.io/";
-export declare const formatModelName: (models: ReturnType<typeof availableModels>, model: string, inquirerPrompt: typeof inquirer.prompt) => Promise<string>;
-export declare function connectToAIGNEHub(url: string): Promise<{
-    apiKey: string;
-    url: string;
-} | {
-    apiKey: undefined;
-    url: undefined;
-}>;
-export declare const checkConnectionStatus: (host: string) => Promise<{
-    apiKey: any;
-    url: string;
-}>;
-export declare function loadAIGNE(path: string, options?: Pick<RunOptions, "model" | "aigneHubUrl">, actionOptions?: {
-    inquirerPromptFn?: (prompt: {
-        type: string;
-        name: string;
-        message: string;
-        choices: {
-            name: string;
-            value: any;
-        }[];
-        default: any;
-    }) => Promise<any>;
-    runTest?: boolean;
+export declare function loadAIGNE({ path, options, modelOptions, actionOptions, }: {
+    path?: string;
+    options?: Model & Pick<RunOptions, "model" | "aigneHubUrl">;
+    modelOptions?: ChatModelOptions;
+    actionOptions?: {
+        inquirerPromptFn?: LoadCredentialOptions["inquirerPromptFn"];
+        runTest?: boolean;
+    };
 }): Promise<AIGNE<import("@aigne/core").UserContext>>;
-export {};

package/dist/utils/load-aigne.js

@@ -1,288 +1,54 @@
 import { existsSync, mkdirSync } from "node:fs";
-import { readFile, writeFile } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { availableModels, findModel, loadModel } from "@aigne/aigne-hub";
+import { AIGNE_ENV_FILE, checkConnectionStatus, AIGNE_HUB_URL as DEFAULT_AIGNE_HUB_URL, formatModelName, loadModel, parseModelOption, } from "@aigne/aigne-hub";
 import { AIGNE } from "@aigne/core";
 import { loadAIGNEFile } from "@aigne/core/loader/index.js";
-import { logger } from "@aigne/core/utils/logger.js";
-import { AesCrypter } from "@ocap/mcrypto/lib/crypter/aes-legacy.js";
-import crypto from "crypto";
 import inquirer from "inquirer";
-import open from "open";
-import pWaitFor from "p-wait-for";
-import { joinURL, withQuery } from "ufo";
 import { parse, stringify } from "yaml";
 import { availableMemories } from "../constants.js";
-import { parseModelOption } from "./run-with-aigne.js";
-const aes = new AesCrypter();
-export const decrypt = (m, s, i) => aes.decrypt(m, crypto.pbkdf2Sync(i, s, 256, 32, "sha512").toString("hex"));
-export const encrypt = (m, s, i) => aes.encrypt(m, crypto.pbkdf2Sync(i, s, 256, 32, "sha512").toString("hex"));
-const escapeFn = (str) => str.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
-const unescapeFn = (str) => (str + "===".slice((str.length + 3) % 4)).replace(/-/g, "+").replace(/_/g, "/");
-export const encodeEncryptionKey = (key) => escapeFn(Buffer.from(key).toString("base64"));
-export const decodeEncryptionKey = (str) => new Uint8Array(Buffer.from(unescapeFn(str), "base64"));
-const TEST_ENV = process.env.CI || process.env.NODE_ENV === "test";
-export const AIGNE_ENV_FILE = TEST_ENV
-    ? join(homedir(), ".aigne", "test-aigne-hub-connected.yaml")
-    : join(homedir(), ".aigne", "aigne-hub-connected.yaml");
-const request = async (config) => {
-    const headers = {};
-    if (config.requestCount !== undefined) {
-        headers["X-Request-Count"] = config.requestCount.toString();
-    }
-    const response = await fetch(config.url, { method: config.method || "GET", headers });
-    if (!response.ok)
-        throw new Error(`HTTP error! status: ${response.status}`);
-    const data = await response.json();
-    return { data };
-};
-const WELLKNOWN_SERVICE_PATH_PREFIX = "/.well-known/service";
-const ACCESS_KEY_PREFIX = "/api/access-key";
-const ACCESS_KEY_SESSION_API = `${ACCESS_KEY_PREFIX}/session`;
-export const fetchConfigs = async ({ connectUrl, sessionId, fetchInterval, fetchTimeout, }) => {
-    const sessionURL = withQuery(joinURL(connectUrl, ACCESS_KEY_SESSION_API), { sid: sessionId });
-    let requestCount = 0;
-    const condition = async () => {
-        const { data: session } = await request({ url: sessionURL, requestCount });
-        requestCount++;
-        return Boolean(session.accessKeyId && session.accessKeySecret);
-    };
-    await pWaitFor(condition, { interval: fetchInterval, timeout: fetchTimeout });
-    const { data: session } = await request({ url: sessionURL, requestCount });
-    await request({ url: sessionURL, method: "DELETE" });
-    return {
-        ...session,
-        accessKeyId: session.accessKeyId,
-        accessKeySecret: decrypt(session.accessKeySecret, session.accessKeyId, session.challenge),
-    };
-};
-function baseWrapSpinner(_, waiting) {
-    return Promise.resolve(waiting());
-}
-export async function createConnect({ connectUrl, openPage, fetchInterval = 3 * 1000, retry = 1500, source = "Blocklet CLI", connectAction = "connect-cli", wrapSpinner = baseWrapSpinner, closeOnSuccess, intervalFetchConfig, appName = "AIGNE CLI", appLogo = "https://www.aigne.io/favicon.ico?imageFilter=resize&w=32", }) {
-    try {
-        const startSessionURL = joinURL(connectUrl, ACCESS_KEY_SESSION_API);
-        const { data: session } = await request({ url: startSessionURL, method: "POST" });
-        const token = session.id;
-        const pageUrl = withQuery(joinURL(connectUrl, connectAction), {
-            __token__: encodeEncryptionKey(token),
-            source,
-            closeOnSuccess,
-            cli: true,
-            appName: ` ${appName}`,
-            appLogo,
-        });
-        openPage?.(pageUrl);
-        return await wrapSpinner(`Waiting for connection: ${connectUrl}`, async () => {
-            const checkAuthorizeStatus = intervalFetchConfig ?? fetchConfigs;
-            const authorizeStatus = await checkAuthorizeStatus({
-                connectUrl,
-                sessionId: token,
-                fetchTimeout: retry * fetchInterval,
-                fetchInterval: retry,
-            });
-            return authorizeStatus;
-        });
-    }
-    catch (e) {
-        console.error(e);
-        throw e;
-    }
-}
-const AGENT_HUB_PROVIDER = "aignehub";
-const DEFAULT_AIGNE_HUB_MODEL = "openai/gpt-4o";
-const DEFAULT_AIGNE_HUB_PROVIDER_MODEL = `${AGENT_HUB_PROVIDER}:${DEFAULT_AIGNE_HUB_MODEL}`;
-export const DEFAULT_URL = "https://hub.aigne.io/";
-export const formatModelName = async (models, model, inquirerPrompt) => {
-    if (!model)
-        return DEFAULT_AIGNE_HUB_PROVIDER_MODEL;
-    const { provider, name } = parseModelOption(model);
-    if (!provider) {
-        return DEFAULT_AIGNE_HUB_PROVIDER_MODEL;
-    }
-    const providerName = provider.replace(/-/g, "");
-    if (providerName.includes(AGENT_HUB_PROVIDER)) {
-        return model;
-    }
-    const m = findModel(models, providerName);
-    if (!m)
-        throw new Error(`Unsupported model: ${provider} ${name}`);
-    const apiKeyEnvName = Array.isArray(m.apiKeyEnvName) ? m.apiKeyEnvName : [m.apiKeyEnvName];
-    if (apiKeyEnvName.some((name) => name && process.env[name])) {
-        return model;
-    }
-    if (TEST_ENV) {
-        return `${AGENT_HUB_PROVIDER}:${provider}/${name}`;
-    }
-    const result = await inquirerPrompt({
-        type: "list",
-        name: "useAigneHub",
-        message: `Seems no API Key configured for ${provider}/${name}, select your preferred way to continue:`,
-        choices: [
-            {
-                name: `Connect to AIGNE Hub to use ${name} (Recommended since free credits available)`,
-                value: true,
-            },
-            {
-                name: `Exit and bring my owner API Key by set ${apiKeyEnvName.join(", ")}`,
-                value: false,
-            },
-        ],
-        default: true,
-    });
-    if (!result.useAigneHub)
-        return model;
-    return `${AGENT_HUB_PROVIDER}:${provider}/${name}`;
-};
-export async function connectToAIGNEHub(url) {
-    const { origin, host } = new URL(url);
-    const connectUrl = joinURL(origin, WELLKNOWN_SERVICE_PATH_PREFIX);
-    const BLOCKLET_JSON_PATH = "__blocklet__.js?type=json";
-    const blockletInfo = await fetch(joinURL(origin, BLOCKLET_JSON_PATH));
-    const blocklet = await blockletInfo.json();
-    const aigneHubMount = (blocklet?.componentMountPoints || []).find((m) => m.did === "z8ia3xzq2tMq8CRHfaXj1BTYJyYnEcHbqP8cJ");
-    try {
-        const result = await createConnect({
-            connectUrl: connectUrl,
-            connectAction: "gen-simple-access-key",
-            source: `@aigne/cli connect to AIGNE hub`,
-            closeOnSuccess: true,
-            openPage: (pageUrl) => open(pageUrl),
-        });
-        const accessKeyOptions = {
-            apiKey: result.accessKeySecret,
-            url: joinURL(origin, aigneHubMount?.mountPoint || ""),
-        };
-        // After redirection, write the AIGNE Hub access token
-        const aigneDir = join(homedir(), ".aigne");
-        if (!existsSync(aigneDir)) {
-            mkdirSync(aigneDir, { recursive: true });
-        }
-        const envs = parse(await readFile(AIGNE_ENV_FILE, "utf8").catch(() => stringify({})));
-        await writeFile(AIGNE_ENV_FILE, stringify({
-            ...envs,
-            [host]: {
-                AIGNE_HUB_API_KEY: accessKeyOptions.apiKey,
-                AIGNE_HUB_API_URL: accessKeyOptions.url,
-            },
-            default: {
-                AIGNE_HUB_API_URL: accessKeyOptions.url,
-            },
-        })).catch((err) => {
-            logger.error("Failed to write AIGNE Hub access token to .aigne/aigne-hub-connected.yaml", err.message);
-            throw err;
-        });
-        return accessKeyOptions;
-    }
-    catch (error) {
-        logger.error("Failed to connect to AIGNE Hub", error.message);
-        return { apiKey: undefined, url: undefined };
-    }
-}
-export const checkConnectionStatus = async (host) => {
-    // aigne-hub access token
-    if (!existsSync(AIGNE_ENV_FILE)) {
-        throw new Error("AIGNE_HUB_API_KEY file not found, need to login first");
-    }
-    const data = await readFile(AIGNE_ENV_FILE, "utf8");
-    if (!data.includes("AIGNE_HUB_API_KEY")) {
-        throw new Error("AIGNE_HUB_API_KEY key not found, need to login first");
-    }
-    const envs = parse(data);
-    if (!envs[host]) {
-        throw new Error("AIGNE_HUB_API_KEY host not found, need to login first");
-    }
-    const env = envs[host];
-    if (!env.AIGNE_HUB_API_KEY) {
-        throw new Error("AIGNE_HUB_API_KEY key not found, need to login first");
-    }
-    return {
-        apiKey: env.AIGNE_HUB_API_KEY,
-        url: joinURL(env.AIGNE_HUB_API_URL),
-    };
-};
+const isTest = process.env.CI || process.env.NODE_ENV === "test";
 const mockInquirerPrompt = (() => Promise.resolve({ useAigneHub: true }));
-export async function loadAIGNE(path, options, actionOptions) {
+async function prepareAIGNEConfig(options, inquirerPromptFn) {
     const aigneDir = join(homedir(), ".aigne");
     if (!existsSync(aigneDir)) {
         mkdirSync(aigneDir, { recursive: true });
     }
     const envs = parse(await readFile(AIGNE_ENV_FILE, "utf8").catch(() => stringify({})));
-    const inquirerPrompt = (actionOptions?.inquirerPromptFn ??
-        inquirer.prompt);
-    const models = availableModels();
+    const inquirerPrompt = (inquirerPromptFn ?? inquirer.prompt);
+    // get aigne hub url
     const configUrl = options?.aigneHubUrl || process.env.AIGNE_HUB_API_URL;
-    const AIGNE_HUB_URL = configUrl || envs?.default?.AIGNE_HUB_API_URL || DEFAULT_URL;
-    const connectUrl = joinURL(new URL(AIGNE_HUB_URL).origin, WELLKNOWN_SERVICE_PATH_PREFIX);
+    const AIGNE_HUB_URL = configUrl || envs?.default?.AIGNE_HUB_API_URL || DEFAULT_AIGNE_HUB_URL;
     const { host } = new URL(AIGNE_HUB_URL);
-    const { aigne } = await loadAIGNEFile(path).catch(() => ({ aigne: null }));
     const result = await checkConnectionStatus(host).catch(() => null);
     const alreadyConnected = Boolean(result?.apiKey);
-    const modelName = await formatModelName(models, options?.model || `${aigne?.model?.provider ?? ""}:${aigne?.model?.name ?? ""}`, alreadyConnected ? mockInquirerPrompt : inquirerPrompt);
-    let credential = {};
-    if (TEST_ENV && !actionOptions?.runTest) {
-        const model = await loadModel(parseModelOption(modelName));
+    return { AIGNE_HUB_URL, inquirerPrompt: alreadyConnected ? mockInquirerPrompt : inquirerPrompt };
+}
+export async function loadAIGNE({ path, options, modelOptions, actionOptions, }) {
+    const { AIGNE_HUB_URL, inquirerPrompt } = await prepareAIGNEConfig(options, actionOptions?.inquirerPromptFn);
+    const { temperature, topP, presencePenalty, frequencyPenalty } = options || {};
+    let modelName = options?.model || "";
+    if (path) {
+        const { aigne } = await loadAIGNEFile(path).catch(() => ({ aigne: null }));
+        const modelFromPath = `${aigne?.model?.provider ?? ""}:${aigne?.model?.name ?? ""}`;
+        modelName = modelName || modelFromPath;
+    }
+    // format model name
+    const formattedModelName = isTest ? modelName : await formatModelName(modelName, inquirerPrompt);
+    if (isTest && path && !actionOptions?.runTest) {
+        const model = await loadModel(parseModelOption(formattedModelName));
         return await AIGNE.load(path, { loadModel, memories: availableMemories, model });
     }
-    if ((modelName.toLocaleLowerCase() || "").includes(AGENT_HUB_PROVIDER)) {
-        try {
-            credential = await checkConnectionStatus(host);
-        }
-        catch (error) {
-            if (error instanceof Error && error.message.includes("login first")) {
-                let aigneHubUrl = connectUrl;
-                if (!configUrl) {
-                    const { subscribe } = await inquirerPrompt({
-                        type: "list",
-                        name: "subscribe",
-                        message: "No LLM API Keys or AIGNE Hub connections found. How would you like to proceed?",
-                        choices: [
-                            {
-                                name: "Connect to the Arcblock official AIGNE Hub (recommended, free credits for new users)",
-                                value: "official",
-                            },
-                            connectUrl.includes(DEFAULT_URL)
-                                ? {
-                                    name: "Connect to your own AIGNE Hub instance (self-hosted)",
-                                    value: "custom",
-                                }
-                                : null,
-                            {
-                                name: "Exit and configure my own LLM API Keys",
-                                value: "manual",
-                            },
-                        ].filter(Boolean),
-                        default: "official",
-                    });
-                    if (subscribe === "custom") {
-                        const { customUrl } = await inquirerPrompt({
-                            type: "input",
-                            name: "customUrl",
-                            message: "Enter the URL of your AIGNE Hub:",
-                            validate(input) {
-                                try {
-                                    const url = new URL(input);
-                                    return url.protocol.startsWith("http")
-                                        ? true
-                                        : "Must be a valid URL with http or https";
-                                }
-                                catch {
-                                    return "Invalid URL";
-                                }
-                            },
-                        });
-                        aigneHubUrl = customUrl;
-                    }
-                    else if (subscribe === "manual") {
-                        console.log("You chose to configure your own LLM API Keys. Exiting...");
-                        process.exit(0);
-                    }
-                }
-                credential = await connectToAIGNEHub(aigneHubUrl);
-            }
-        }
+    const model = await loadModel({
+        ...parseModelOption(formattedModelName),
+        temperature,
+        topP,
+        presencePenalty,
+        frequencyPenalty,
+    }, modelOptions, { aigneHubUrl: AIGNE_HUB_URL, inquirerPromptFn: actionOptions?.inquirerPromptFn });
+    if (path) {
+        return await AIGNE.load(path, { loadModel, memories: availableMemories, model });
     }
-    const model = await loadModel(parseModelOption(modelName), undefined, credential);
-    return await AIGNE.load(path, { loadModel, memories: availableMemories, model });
+    return new AIGNE({ model });
 }

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

@@ -1,4 +1,4 @@
-import { type Agent, AIGNE, type ChatModelOptions, type Message } from "@aigne/core";
+import { type Agent, type 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";
@@ -41,16 +41,14 @@ export declare const createRunAIGNECommand: (yargs: Argv) => Argv<{
     force: boolean;
 } & {
     "log-level": LogLevel;
+} & {
+    "aigne-hub-url": string | undefined;
 }>;
 export declare function parseAgentInputByCommander(agent: Agent, options?: RunAIGNECommandOptions & {
     inputKey?: string;
     argv?: string[];
     defaultInput?: string | Message;
 }): Promise<Message>;
-export declare const parseModelOption: (model?: string) => {
-    provider: string | undefined;
-    name: string | undefined;
-};
 export declare function runWithAIGNE(agentCreator: ((aigne: AIGNE) => PromiseOrValue<Agent>) | Agent, { argv, chatLoopOptions, modelOptions, outputKey, }?: {
     argv?: typeof process.argv;
     chatLoopOptions?: ChatLoopOptions;

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

@@ -4,8 +4,8 @@ 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 { availableModels, loadModel } from "@aigne/aigne-hub";
-import { AIAgent, AIGNE, DEFAULT_OUTPUT_KEY, readAllString, UserAgent, } from "@aigne/core";
+import { availableModels, parseModelOption } from "@aigne/aigne-hub";
+import { AIAgent, DEFAULT_OUTPUT_KEY, readAllString, UserAgent, } from "@aigne/core";
 import { getLevelFromEnv, LogLevel, logger } from "@aigne/core/utils/logger.js";
 import { flat, isEmpty, tryOrThrow } from "@aigne/core/utils/type-utils.js";
 import chalk from "chalk";
@@ -14,6 +14,7 @@ import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import { ZodError, ZodObject, z } from "zod";
 import { TerminalTracer } from "../tracer/terminal.js";
+import { loadAIGNE } from "./load-aigne.js";
 import { DEFAULT_CHAT_INPUT_KEY, runChatLoopInTerminal, } from "./run-chat-loop.js";
 export const createRunAIGNECommand = (yargs) => yargs
     .option("chat", {
@@ -81,6 +82,10 @@ export const createRunAIGNECommand = (yargs) => yargs
     type: "string",
     default: getLevelFromEnv(logger.options.ns) || LogLevel.INFO,
     coerce: customZodError("--log-level", (s) => z.nativeEnum(LogLevel).parse(s)),
+})
+    .option("aigne-hub-url", {
+    describe: "Custom AIGNE Hub service URL. Used to fetch remote agent definitions or models. ",
+    type: "string",
 });
 export async function parseAgentInputByCommander(agent, options = {}) {
     const inputSchemaShape = flat(agent instanceof AIAgent ? agent.inputKey : undefined, agent.inputSchema instanceof ZodObject ? Object.keys(agent.inputSchema.shape) : []);
@@ -123,24 +128,22 @@ export async function parseAgentInputByCommander(agent, options = {}) {
     }
     return input;
 }
-export const parseModelOption = (model) => {
-    const { provider, name } = (model || process.env.MODEL)?.match(/(?<provider>[^:]*)(:(?<name>(\S+)))?/)?.groups ?? {};
-    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) => {
         if (options.logLevel) {
             logger.level = options.logLevel;
         }
-        const model = await loadModel({
-            ...parseModelOption(options.model),
-            temperature: options.temperature,
-            topP: options.topP,
-            presencePenalty: options.presencePenalty,
-            frequencyPenalty: options.frequencyPenalty,
-        }, modelOptions);
-        const aigne = new AIGNE({ model });
+        const aigne = await loadAIGNE({
+            options: {
+                ...parseModelOption(options.model),
+                temperature: options.temperature,
+                topP: options.topP,
+                presencePenalty: options.presencePenalty,
+                frequencyPenalty: options.frequencyPenalty,
+            },
+            modelOptions,
+        });
         try {
             const agent = typeof agentCreator === "function" ? await agentCreator(aigne) : agentCreator;
             const input = await parseAgentInputByCommander(agent, {

package/dist/utils/string-utils.d.ts

@@ -0,0 +1 @@
+export declare function highlightUrl(str: string): string;

package/dist/utils/string-utils.js

@@ -0,0 +1,4 @@
+import chalk from "chalk";
+export function highlightUrl(str) {
+    return str.replace(/https?:\/\/[^\s]+/g, (url) => chalk.cyan(url));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/cli",
-  "version": "1.33.1",
+  "version": "1.35.0",
   "description": "Your command center for agent development",
   "publishConfig": {
     "access": "public"
@@ -51,10 +51,9 @@
     "@inquirer/type": "^3.0.8",
     "@listr2/prompt-adapter-inquirer": "^3.0.1",
     "@modelcontextprotocol/sdk": "^1.15.0",
-    "@ocap/mcrypto": "^1.21.0",
     "@smithy/node-http-handler": "^4.1.0",
     "chalk": "^5.4.1",
-    "crypto": "^1.0.1",
+    "cli-table3": "^0.6.5",
     "detect-port": "^2.1.0",
     "dotenv-flow": "^4.1.0",
     "express": "^5.1.0",
@@ -64,22 +63,21 @@
     "inquirer": "^12.7.0",
     "log-update": "^6.1.0",
     "marked": "^16.0.0",
-    "open": "10.1.2",
+    "nunjucks": "^3.2.4",
     "openai": "^5.8.3",
-    "p-wait-for": "^5.0.2",
     "prettier": "^3.6.2",
     "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.17",
-    "@aigne/agentic-memory": "^1.0.17",
-    "@aigne/aigne-hub": "^0.4.8",
-    "@aigne/core": "^1.48.0",
+    "@aigne/agent-library": "^1.21.19",
+    "@aigne/agentic-memory": "^1.0.19",
+    "@aigne/aigne-hub": "^0.5.0",
+    "@aigne/default-memory": "^1.1.1",
     "@aigne/observability-api": "^0.9.0",
-    "@aigne/default-memory": "^1.0.17",
-    "@aigne/openai": "^0.10.17"
+    "@aigne/core": "^1.49.1",
+    "@aigne/openai": "^0.11.1"
   },
   "devDependencies": {
     "@types/archiver": "^6.0.3",

package/dist/commands/connect.d.ts

@@ -1,13 +0,0 @@
-import type { CommandModule } from "yargs";
-interface ConnectOptions {
-    url?: string;
-}
-interface StatusInfo {
-    host: string;
-    apiUrl: string;
-    apiKey: string;
-}
-export declare function getConnectionStatus(): Promise<StatusInfo[]>;
-export declare function displayStatus(statusList: StatusInfo[]): Promise<void>;
-export declare function createConnectCommand(): CommandModule<unknown, ConnectOptions>;
-export {};

package/dist/commands/connect.js

@@ -1,99 +0,0 @@
-import { existsSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import chalk from "chalk";
-import { parse } from "yaml";
-import { getUserInfo } from "../utils/aigne-hub-user.js";
-import { AIGNE_ENV_FILE, connectToAIGNEHub, DEFAULT_URL } from "../utils/load-aigne.js";
-const formatNumber = (balance) => {
-    const balanceNum = String(balance).split(".")[0];
-    return chalk.yellow((balanceNum || "").replace(/\B(?=(\d{3})+(?!\d))/g, ","));
-};
-export async function getConnectionStatus() {
-    if (!existsSync(AIGNE_ENV_FILE)) {
-        return [];
-    }
-    try {
-        const data = await readFile(AIGNE_ENV_FILE, "utf8");
-        const envs = parse(data);
-        const statusList = [];
-        for (const [host, config] of Object.entries(envs)) {
-            statusList.push({
-                host,
-                apiUrl: config.AIGNE_HUB_API_URL,
-                apiKey: config.AIGNE_HUB_API_KEY,
-            });
-        }
-        return statusList;
-    }
-    catch {
-        return [];
-    }
-}
-export async function displayStatus(statusList) {
-    if (statusList.length === 0) {
-        console.log(chalk.yellow("No AIGNE Hub connections found."));
-        console.log("Use 'aigne connect <url>' to connect to a hub.");
-        return;
-    }
-    console.log(chalk.cyan("AIGNE Hub Connection Status:\n"));
-    const defaultStatus = statusList.find((status) => status.host === "default")?.apiUrl || DEFAULT_URL;
-    for (const status of statusList.filter((status) => status.host !== "default")) {
-        const userInfo = await getUserInfo({ baseUrl: status.apiUrl, apiKey: status.apiKey }).catch((e) => {
-            console.error(e);
-            return null;
-        });
-        const isConnected = new URL(status.apiUrl).origin === new URL(defaultStatus).origin;
-        const statusIcon = isConnected ? chalk.green("✓") : chalk.red("✗");
-        const statusText = isConnected ? "Connected" : "Disconnected";
-        console.log(`${statusIcon} ${chalk.bold(status.host)}`);
-        console.log(`   Status: ${statusText}`);
-        if (userInfo) {
-            console.log(`   User: ${userInfo?.user.fullName}`);
-            console.log(`   User DID: ${userInfo?.user.did}`);
-            if (userInfo?.user.email) {
-                console.log(`   Email: ${userInfo?.user.email}`);
-            }
-            if (userInfo?.creditBalance) {
-                const balance = formatNumber(userInfo?.creditBalance?.balance);
-                const total = formatNumber(userInfo?.creditBalance?.total);
-                console.log(`   Plan: ${balance} / ${total}`);
-            }
-            console.log(`   Billing URL: ${userInfo?.paymentLink ? chalk.green(userInfo.paymentLink) : chalk.red("N/A")}`);
-        }
-        console.log("");
-    }
-}
-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.cyan(`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);
-            }
-        },
-    };
-}