@aigne/cli 1.24.1 → 1.25.0

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # Changelog
 
+## [1.25.0](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.24.1...cli-v1.25.0) (2025-07-24)
+
+
+### Features
+
+* **cli:** support aigne hub connect and model use ([#267](https://github.com/AIGNE-io/aigne-framework/issues/267)) ([8e5a32a](https://github.com/AIGNE-io/aigne-framework/commit/8e5a32afc64593137153d7407bde13837312ac70))
+
+
+### Bug Fixes
+
+* ci lint ([#278](https://github.com/AIGNE-io/aigne-framework/issues/278)) ([b23dea9](https://github.com/AIGNE-io/aigne-framework/commit/b23dea98bf91082ce7429b766dff28cfa5163cd9))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/agent-library bumped to 1.21.4
+    * @aigne/agentic-memory bumped to 1.0.4
+    * @aigne/aigne-hub bumped to 0.2.0
+    * @aigne/anthropic bumped to 0.10.0
+    * @aigne/bedrock bumped to 0.8.4
+    * @aigne/core bumped to 1.38.0
+    * @aigne/deepseek bumped to 0.7.4
+    * @aigne/default-memory bumped to 1.0.4
+    * @aigne/gemini bumped to 0.8.4
+    * @aigne/ollama bumped to 0.7.4
+    * @aigne/open-router bumped to 0.7.4
+    * @aigne/openai bumped to 0.10.4
+    * @aigne/xai bumped to 0.7.4
+
 ## [1.24.1](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.24.0...cli-v1.24.1) (2025-07-22)
 
 

package/dist/commands/run.js

@@ -2,16 +2,16 @@ import assert from "node:assert";
 import { cp, mkdir, rm } from "node:fs/promises";
 import { homedir } from "node:os";
 import { isAbsolute, join, resolve } from "node:path";
-import { AIGNE } from "@aigne/core";
-import { loadModel } from "@aigne/core/loader/index.js";
 import { logger } from "@aigne/core/utils/logger.js";
 import { isNonNullable } from "@aigne/core/utils/type-utils.js";
 import { Listr, PRESET_TIMER } from "@aigne/listr2";
+import { select } from "@inquirer/prompts";
+import { ListrInquirerPromptAdapter } from "@listr2/prompt-adapter-inquirer";
 import { config } from "dotenv-flow";
-import { availableMemories, availableModels } from "../constants.js";
 import { isV1Package, toAIGNEPackage } from "../utils/agent-v1.js";
 import { downloadAndExtract } from "../utils/download.js";
-import { createRunAIGNECommand, parseAgentInputByCommander, parseModelOption, runAgentWithAIGNE, } from "../utils/run-with-aigne.js";
+import { loadAIGNE } from "../utils/load-aigne.js";
+import { createRunAIGNECommand, parseAgentInputByCommander, runAgentWithAIGNE, } from "../utils/run-with-aigne.js";
 export function createRunCommand({ aigneFilePath } = {}) {
     return createRunAIGNECommand()
         .description("Run AIGNE from the specified agent")
@@ -43,12 +43,16 @@ export function createRunCommand({ aigneFilePath } = {}) {
             },
             {
                 title: "Initialize AIGNE",
-                task: async (ctx) => {
+                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,
+                    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;
                 },
@@ -97,13 +101,6 @@ ${aigne.agents.map((agent) => `  - ${agent.name}`).join("\n")}
         .showHelpAfterError(true)
         .showSuggestionAfterError(true);
 }
-async function loadAIGNE(path, options) {
-    const models = availableModels();
-    const model = options.model
-        ? await loadModel(models, parseModelOption(options.model))
-        : undefined;
-    return await AIGNE.load(path, { models, memories: availableMemories, model });
-}
 async function downloadPackage(url, cacheDir) {
     await rm(cacheDir, { recursive: true, force: true });
     await mkdir(cacheDir, { recursive: true });

package/dist/commands/serve-mcp.js

@@ -1,8 +1,7 @@
 import { isAbsolute, resolve } from "node:path";
-import { AIGNE } from "@aigne/core";
 import { tryOrThrow } from "@aigne/core/utils/type-utils.js";
 import { Command } from "commander";
-import { availableMemories, availableModels } from "../constants.js";
+import { loadAIGNE } from "../utils/load-aigne.js";
 import { serveMCPServer } from "../utils/serve-mcp.js";
 const DEFAULT_PORT = () => tryOrThrow(() => {
     const { PORT } = process.env;
@@ -24,10 +23,7 @@ export function createServeMCPCommand({ aigneFilePath } = {}) {
         const path = aigneFilePath || options.path;
         const absolutePath = isAbsolute(path) ? path : resolve(process.cwd(), path);
         const port = options.port || DEFAULT_PORT();
-        const aigne = await AIGNE.load(absolutePath, {
-            models: availableModels(),
-            memories: availableMemories,
-        });
+        const aigne = await loadAIGNE(absolutePath);
         await serveMCPServer({
             aigne,
             host: options.host,

package/dist/commands/test.js

@@ -1,9 +1,8 @@
 import assert from "node:assert";
 import { spawnSync } from "node:child_process";
 import { isAbsolute, resolve } from "node:path";
-import { AIGNE } from "@aigne/core";
 import { Command } from "commander";
-import { availableMemories, availableModels } from "../constants.js";
+import { loadAIGNE } from "../utils/load-aigne.js";
 export function createTestCommand({ aigneFilePath } = {}) {
     return new Command("test")
         .description("Run tests in the specified agents directory")
@@ -11,10 +10,7 @@ export function createTestCommand({ aigneFilePath } = {}) {
         .action(async (options) => {
         const path = aigneFilePath || options.path;
         const absolutePath = isAbsolute(path) ? path : resolve(process.cwd(), path);
-        const aigne = await AIGNE.load(absolutePath, {
-            models: availableModels(),
-            memories: availableMemories,
-        });
+        const aigne = await loadAIGNE(absolutePath);
         assert(aigne.rootDir);
         spawnSync("node", ["--test"], { cwd: aigne.rootDir, stdio: "inherit" });
     })

package/dist/constants.js

@@ -28,14 +28,17 @@ export function availableModels() {
     return [
         {
             name: OpenAIChatModel.name,
+            apiKeyEnvName: "OPENAI_API_KEY",
             create: (params) => new OpenAIChatModel({ ...params, clientOptions }),
         },
         {
             name: AnthropicChatModel.name,
+            apiKeyEnvName: "ANTHROPIC_API_KEY",
             create: (params) => new AnthropicChatModel({ ...params, clientOptions }),
         },
         {
             name: BedrockChatModel.name,
+            apiKeyEnvName: "AWS_ACCESS_KEY_ID",
             create: (params) => new BedrockChatModel({
                 ...params,
                 clientOptions: {
@@ -46,26 +49,32 @@ export function availableModels() {
         },
         {
             name: DeepSeekChatModel.name,
+            apiKeyEnvName: "DEEPSEEK_API_KEY",
             create: (params) => new DeepSeekChatModel({ ...params, clientOptions }),
         },
         {
             name: GeminiChatModel.name,
+            apiKeyEnvName: "GEMINI_API_KEY",
             create: (params) => new GeminiChatModel({ ...params, clientOptions }),
         },
         {
             name: OllamaChatModel.name,
+            apiKeyEnvName: "OLLAMA_API_KEY",
             create: (params) => new OllamaChatModel({ ...params, clientOptions }),
         },
         {
             name: OpenRouterChatModel.name,
+            apiKeyEnvName: "OPEN_ROUTER_API_KEY",
             create: (params) => new OpenRouterChatModel({ ...params, clientOptions }),
         },
         {
             name: XAIChatModel.name,
+            apiKeyEnvName: "XAI_API_KEY",
             create: (params) => new XAIChatModel({ ...params, clientOptions }),
         },
         {
             name: AIGNEHubChatModel.name,
+            apiKeyEnvName: "AIGNE_HUB_API_KEY",
             create: (params) => new AIGNEHubChatModel({ ...params, clientOptions }),
         },
     ];

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

@@ -0,0 +1,19 @@
+import { AIGNE } from "@aigne/core";
+import { type RunAIGNECommandOptions } from "./run-with-aigne.js";
+export interface RunOptions extends RunAIGNECommandOptions {
+    path: string;
+    entryAgent?: string;
+    cacheDir?: string;
+}
+export declare function loadAIGNE(path: string, options?: RunOptions, checkAuthorizeOptions?: {
+    inquirerPromptFn?: (prompt: {
+        type: string;
+        name: string;
+        message: string;
+        choices: {
+            name: string;
+            value: any;
+        }[];
+        default: any;
+    }) => Promise<any>;
+}): Promise<AIGNE<import("@aigne/core").UserContext>>;

package/dist/utils/load-aigne.js

@@ -0,0 +1,209 @@
+import { existsSync } from "node:fs";
+import { appendFile, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { AIGNE } from "@aigne/core";
+import { loadModel } from "@aigne/core/loader/index.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, availableModels } from "../constants.js";
+import { parseModelOption } from "./run-with-aigne.js";
+const aes = new AesCrypter();
+const decrypt = (m, s, i) => aes.decrypt(m, crypto.pbkdf2Sync(i, s, 256, 32, "sha512").toString("hex"));
+const escapeFn = (str) => str.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+const encodeEncryptionKey = (key) => escapeFn(Buffer.from(key).toString("base64"));
+const request = async (config) => {
+    const response = await fetch(config.url, { method: config.method || "GET" });
+    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`;
+const fetchConfigs = async ({ connectUrl, sessionId, fetchInterval, fetchTimeout, }) => {
+    const sessionURL = withQuery(joinURL(connectUrl, ACCESS_KEY_SESSION_API), { sid: sessionId });
+    const condition = async () => {
+        const { data: session } = await request({ url: sessionURL });
+        return Boolean(session.accessKeyId && session.accessKeySecret);
+    };
+    await pWaitFor(condition, { interval: fetchInterval, timeout: fetchTimeout });
+    const { data: session } = await request({ url: sessionURL });
+    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());
+}
+async function createConnect({ connectUrl, openPage, fetchInterval = 3 * 1000, retry = 1500, source = "Blocklet CLI", connectAction = "connect-cli", wrapSpinner = baseWrapSpinner, closeOnSuccess, intervalFetchConfig, }) {
+    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: " AIGNE CLI",
+            appLogo: "https://www.aigne.io/favicon.ico?imageFilter=resize&w=32",
+        });
+        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}`;
+const DEFAULT_URL = "https://hub.aigne.io/";
+const formatModelName = async (models, model, inquirerPrompt) => {
+    if (process.env.NODE_ENV === "test")
+        return model;
+    if (!model)
+        return DEFAULT_AIGNE_HUB_PROVIDER_MODEL;
+    const { provider, name } = parseModelOption(model);
+    if (!provider || !name) {
+        return DEFAULT_AIGNE_HUB_PROVIDER_MODEL;
+    }
+    const providerName = provider.replace(/-/g, "");
+    if (providerName.includes(AGENT_HUB_PROVIDER)) {
+        return model;
+    }
+    const m = models.find((m) => m.name.toLowerCase().includes(providerName.toLowerCase()));
+    if (!m)
+        throw new Error(`Unsupported model: ${provider} ${name}`);
+    if (m.apiKeyEnvName && process.env[m.apiKeyEnvName]) {
+        return model;
+    }
+    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 ${m.apiKeyEnvName}`,
+                value: false,
+            },
+        ],
+        default: true,
+    });
+    if (!result.useAigneHub)
+        return model;
+    return `${AGENT_HUB_PROVIDER}:${provider}/${name}`;
+};
+export async function loadAIGNE(path, options, checkAuthorizeOptions) {
+    const models = availableModels();
+    const AIGNE_ENV_FILE = join(homedir(), ".aigne", "aigne-hub-connected.yaml");
+    const AIGNE_HUB_URL = process.env.AIGNE_HUB_API_URL || DEFAULT_URL;
+    const connectUrl = joinURL(new URL(AIGNE_HUB_URL).origin, WELLKNOWN_SERVICE_PATH_PREFIX);
+    const inquirerPrompt = (checkAuthorizeOptions?.inquirerPromptFn ??
+        inquirer.prompt);
+    let accessKeyOptions = {};
+    const modelName = await formatModelName(models, options?.model || "", inquirerPrompt);
+    if (!process.env.CI) {
+        if ((modelName.toLocaleLowerCase() || "").includes(AGENT_HUB_PROVIDER)) {
+            const { origin, host } = new URL(AIGNE_HUB_URL);
+            try {
+                // 检查 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");
+                }
+                accessKeyOptions = {
+                    accessKey: env.AIGNE_HUB_API_KEY,
+                    url: joinURL(env.AIGNE_HUB_API_URL),
+                };
+            }
+            catch (error) {
+                if (error instanceof Error && error.message.includes("login first")) {
+                    // If none or invalid, prompt the user to proceed
+                    const subscribePrompt = await inquirerPrompt({
+                        type: "list",
+                        name: "subscribe",
+                        message: "No LLM API Keys or AIGNE Hub connections found, select your preferred way to continue:",
+                        choices: [
+                            {
+                                name: "Connect to AIGNE Hub with just a few clicks, free credits eligible for new users (Recommended)",
+                                value: true,
+                            },
+                            { name: "Exit and configure my own LLM API Keys", value: false },
+                        ],
+                        default: true,
+                    });
+                    if (!subscribePrompt.subscribe) {
+                        console.warn("The AIGNE Hub connection has been cancelled");
+                        process.exit(0);
+                    }
+                    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),
+                        });
+                        accessKeyOptions = {
+                            accessKey: result.accessKeySecret,
+                            url: joinURL(origin, aigneHubMount?.mountPoint || ""),
+                        };
+                        // After redirection, write the AIGNE Hub access token
+                        await appendFile(AIGNE_ENV_FILE, stringify({
+                            [host]: {
+                                AIGNE_HUB_API_KEY: accessKeyOptions.accessKey,
+                                AIGNE_HUB_API_URL: accessKeyOptions.url,
+                            },
+                        }));
+                    }
+                    catch (error) {
+                        console.error(error);
+                    }
+                }
+            }
+        }
+    }
+    const model = await loadModel(models, parseModelOption(modelName), undefined, accessKeyOptions);
+    return await AIGNE.load(path, { models, memories: availableMemories, model });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/cli",
-  "version": "1.24.1",
+  "version": "1.25.0",
   "description": "cli for AIGNE framework",
   "publishConfig": {
     "access": "public"
@@ -37,10 +37,14 @@
   "dependencies": {
     "@aigne/listr2": "^1.0.10",
     "@aigne/marked-terminal": "^7.3.2",
+    "@inquirer/prompts": "^7.6.0",
+    "@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",
     "commander": "^14.0.0",
+    "crypto": "^1.0.1",
     "detect-port": "^2.1.0",
     "dotenv-flow": "^4.1.0",
     "express": "^5.1.0",
@@ -49,25 +53,26 @@
     "https-proxy-agent": "^7.0.6",
     "inquirer": "^12.7.0",
     "marked": "^16.0.0",
+    "open": "10.1.2",
     "prettier": "^3.6.2",
     "tar": "^7.4.3",
     "wrap-ansi": "^9.0.0",
     "yaml": "^2.8.0",
     "zod": "^3.25.67",
-    "@aigne/agent-library": "^1.21.3",
-    "@aigne/aigne-hub": "^0.1.3",
-    "@aigne/agentic-memory": "^1.0.3",
-    "@aigne/anthropic": "^0.9.3",
-    "@aigne/core": "^1.37.0",
-    "@aigne/deepseek": "^0.7.3",
-    "@aigne/default-memory": "^1.0.3",
-    "@aigne/bedrock": "^0.8.3",
-    "@aigne/gemini": "^0.8.3",
+    "@aigne/agentic-memory": "^1.0.4",
+    "@aigne/agent-library": "^1.21.4",
+    "@aigne/bedrock": "^0.8.4",
+    "@aigne/anthropic": "^0.10.0",
+    "@aigne/core": "^1.38.0",
+    "@aigne/aigne-hub": "^0.2.0",
+    "@aigne/deepseek": "^0.7.4",
+    "@aigne/default-memory": "^1.0.4",
+    "@aigne/gemini": "^0.8.4",
+    "@aigne/ollama": "^0.7.4",
     "@aigne/observability-api": "^0.8.0",
-    "@aigne/ollama": "^0.7.3",
-    "@aigne/open-router": "^0.7.3",
-    "@aigne/openai": "^0.10.3",
-    "@aigne/xai": "^0.7.3"
+    "@aigne/openai": "^0.10.4",
+    "@aigne/open-router": "^0.7.4",
+    "@aigne/xai": "^0.7.4"
   },
   "devDependencies": {
     "@types/archiver": "^6.0.3",