@aigne/cli 1.53.1-beta.2 → 1.53.1-beta.4

package/dist/commands/app.js

@@ -1,27 +1,7 @@
-import assert from "node:assert";
-import { spawn } from "node:child_process";
-import { mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { fetch } from "@aigne/core/utils/fetch.js";
-import { logger } from "@aigne/core/utils/logger.js";
-import { jsonSchemaToZod } from "@aigne/json-schema-to-zod";
-import { Listr, PRESET_TIMER } from "@aigne/listr2";
-import { joinURL } from "ufo";
-import { AIGNE_CLI_VERSION } from "../constants.js";
-import { downloadAndExtract } from "../utils/download.js";
-import { withSpinner } from "../utils/spinner.js";
-import { runAIGNEInChildProcess, } from "../utils/workers/run-aigne-in-child-process.js";
-import { withAgentInputSchema } from "../utils/yargs.js";
-import { serveMCPServerFromDir } from "./serve-mcp.js";
-const NPM_PACKAGE_CACHE_TIME_MS = 1000 * 60 * 60 * 24; // 1 day
-/**
- * Check if beta applications should be used based on environment variables
- */
-function shouldUseBetaApps() {
-    const envVar = process.env.AIGNE_USE_BETA_APPS;
-    return envVar === "true" || envVar === "1";
-}
+import { fork } from "node:child_process";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { NeedReinstallBetaError, NeedReinstallError } from "./app/upgrade.js";
 const builtinApps = [
     {
         name: "doc-smith",
@@ -41,337 +21,34 @@ export function createAppCommands({ argv } = {}) {
         command: app.name,
         describe: app.describe,
         aliases: app.aliases,
-        builder: async (y) => {
-            const dir = join(homedir(), ".aigne", "registry.npmjs.org", app.packageName);
-            y.command(upgradeCommandModule({ packageName: app.packageName, dir }));
-            if (!argv || !isUpgradeCommand(argv)) {
-                const { aigne, version } = await loadApplication({
-                    dir,
-                    packageName: app.packageName,
-                    install: true,
+        builder: async (y) => y.help(false).version(false).strict(false),
+        handler: async () => {
+            let retried = false;
+            let retryWithBeta = false;
+            while (true) {
+                const child = fork(join(dirname(fileURLToPath(import.meta.url)), "./app/cli.js"), argv, {
+                    stdio: "inherit",
+                    env: {
+                        ...process.env,
+                        AIGNE_APP_NAME: app.name,
+                        AIGNE_APP_PACKAGE_NAME: app.packageName,
+                        AIGNE_APP_DESCRIPTION: app.describe,
+                        AIGNE_APP_USE_BETA_APPS: retryWithBeta ? "1" : "0",
+                    },
                 });
-                if (aigne.cli?.chat) {
-                    y.command({
-                        ...agentCommandModule({
-                            dir,
-                            agent: aigne.cli.chat,
-                            chat: true,
-                            version,
-                            packageName: app.name,
-                        }),
-                        command: "$0",
-                    });
+                const code = await new Promise((resolve) => {
+                    child.on("exit", (code) => resolve(code));
+                });
+                if (code === NeedReinstallError.code || code === NeedReinstallBetaError.code) {
+                    if (retried)
+                        process.exit(1);
+                    retryWithBeta = code === NeedReinstallBetaError.code;
+                    retried = true;
                 }
-                for (const cliAgent of aigne.cli?.agents ?? []) {
-                    y.command(cliAgentCommandModule({ dir, cliAgent, version, packageName: app.name }));
+                else {
+                    process.exit(code);
                 }
-                y.option("model", {
-                    type: "string",
-                    description: "Model to use for the application, example: openai:gpt-4.1 or google:gemini-2.5-flash",
-                }).command(serveMcpCommandModule({ name: app.name, version, dir }));
-                y.version(`${app.name} v${version}`).alias("version", "v");
             }
-            return y.demandCommand();
         },
-        handler: () => { },
     }));
 }
-const serveMcpCommandModule = ({ name, dir, version, }) => ({
-    command: "serve-mcp",
-    describe: `Serve ${name} a MCP server (streamable http)`,
-    builder: (yargs) => {
-        return yargs
-            .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) => {
-        await serveMCPServerFromDir({
-            ...options,
-            dir,
-            metadata: {
-                appName: name,
-                appVersion: version,
-            },
-        });
-    },
-});
-function isUpgradeCommand(argv) {
-    const skipGlobalOptions = ["-v", "--version"];
-    return argv[1] === "upgrade" && !argv.some((arg) => skipGlobalOptions.includes(arg));
-}
-const upgradeCommandModule = ({ packageName, dir, }) => ({
-    command: "upgrade",
-    describe: `Upgrade ${packageName} to the latest version`,
-    builder: (yargs) => {
-        return yargs
-            .option("beta", {
-            type: "boolean",
-            describe: "Use beta versions if available",
-        })
-            .option("target-version", {
-            type: "string",
-            describe: "Specify a version to upgrade to (default is latest)",
-            alias: ["to", "target"],
-        })
-            .option("force", {
-            type: "boolean",
-            describe: "Force upgrade even if already at latest version",
-            default: false,
-        });
-    },
-    handler: async ({ beta, targetVersion, force }) => {
-        beta ??= shouldUseBetaApps();
-        const npm = await withSpinner("", async () => {
-            if (force)
-                await rm(dir, { force: true, recursive: true });
-            return await getNpmTgzInfo(packageName, { beta, version: targetVersion });
-        });
-        let app = await loadApplication({ packageName, dir });
-        if (!app || force || npm.version !== app.version) {
-            await installApp({ packageName, dir, beta, version: targetVersion });
-            app = await loadApplication({ dir, packageName, install: true });
-            console.log(`\n✅ Upgraded ${packageName} to version ${app.version}`);
-            return;
-        }
-        console.log(`\n✅ ${packageName} is already at the latest version (${app.version})`);
-    },
-});
-export const agentCommandModule = ({ dir, agent, chat, version, packageName, }) => {
-    return {
-        command: agent.name,
-        aliases: agent.alias || [],
-        describe: agent.description || "",
-        builder: async (yargs) => {
-            return withAgentInputSchema(yargs, { inputSchema: jsonSchemaToZod(agent.inputSchema) });
-        },
-        handler: async (options) => {
-            if (options.logLevel)
-                logger.level = options.logLevel;
-            await runAIGNEInChildProcess("invokeCLIAgentFromDir", {
-                dir,
-                agent: agent.name,
-                input: { ...options, chat: chat ?? options.chat },
-                metadata: {
-                    cliVersion: AIGNE_CLI_VERSION,
-                    appName: packageName,
-                    appVersion: version,
-                },
-            });
-            process.exit(0);
-        },
-    };
-};
-export const cliAgentCommandModule = ({ dir, parent, cliAgent, version, packageName, }) => {
-    const { agent, agents } = cliAgent;
-    const name = cliAgent.name || agent?.name;
-    assert(name, "CLI agent must have a name");
-    return {
-        command: name,
-        aliases: cliAgent.alias || agent?.alias || [],
-        describe: cliAgent.description || agent?.description || "",
-        builder: async (yargs) => {
-            if (agent) {
-                withAgentInputSchema(yargs, { inputSchema: jsonSchemaToZod(agent.inputSchema) });
-            }
-            if (agents?.length) {
-                for (const cmd of agents) {
-                    yargs.command(cliAgentCommandModule({
-                        dir,
-                        parent: (parent ?? []).concat(name),
-                        cliAgent: cmd,
-                        version,
-                        packageName,
-                    }));
-                }
-            }
-            if (!agent)
-                yargs.demandCommand();
-            return yargs;
-        },
-        handler: async (options) => {
-            if (!agent)
-                throw new Error("CLI agent is not defined");
-            if (options.logLevel)
-                logger.level = options.logLevel;
-            await runAIGNEInChildProcess("invokeCLIAgentFromDir", {
-                dir,
-                parent,
-                agent: name,
-                input: options,
-                metadata: {
-                    cliVersion: AIGNE_CLI_VERSION,
-                    appName: packageName,
-                    appVersion: version,
-                },
-            });
-            process.exit(0);
-        },
-    };
-};
-export async function loadApplication(options) {
-    const { dir, packageName } = options;
-    const check = await checkInstallation(dir);
-    if (check && !check.expired) {
-        const aigne = await runAIGNEInChildProcess("loadAIGNE", {
-            path: dir,
-            skipModelLoading: true,
-            metadata: {
-                appName: packageName,
-                appVersion: check?.version,
-            },
-        }).catch(async (error) => {
-            logger.error(`⚠️ Failed to load ${packageName}, trying to reinstall:`, error.message);
-            await withSpinner("", async () => {
-                await rm(options.dir, { recursive: true, force: true });
-                await mkdir(options.dir, { recursive: true });
-            });
-        });
-        if (aigne) {
-            return { aigne, version: check.version, isCache: true };
-        }
-    }
-    if (!options.install)
-        return null;
-    const result = await installApp({ dir, packageName, beta: check?.version?.includes("beta") });
-    return {
-        aigne: await runAIGNEInChildProcess("loadAIGNE", {
-            path: dir,
-            skipModelLoading: true,
-            metadata: {
-                appName: packageName,
-                appVersion: result.version,
-            },
-        }),
-        version: result.version,
-    };
-}
-async function readInstallationMetadata(dir) {
-    return safeParseJSON(await readFile(join(dir, ".aigne-cli.json"), "utf-8").catch(() => "{}"));
-}
-async function writeInstallationMetadata(dir, metadata) {
-    await writeFile(join(dir, ".aigne-cli.json"), JSON.stringify(metadata, null, 2));
-}
-async function checkInstallation(dir, { cacheTimeMs = NPM_PACKAGE_CACHE_TIME_MS } = {}) {
-    const s = await stat(join(dir, "package.json")).catch(() => null);
-    if (!s)
-        return null;
-    const version = safeParseJSON(await readFile(join(dir, "package.json"), "utf-8"))?.version;
-    if (!version)
-        return null;
-    const installedAt = (await readInstallationMetadata(dir))?.installedAt;
-    if (!installedAt)
-        return null;
-    const now = Date.now();
-    const expired = now - installedAt > cacheTimeMs;
-    return { version, expired };
-}
-export async function installApp({ dir, packageName, beta, version, }) {
-    return await new Listr([
-        {
-            title: `Fetching ${packageName} metadata`,
-            task: async (ctx, task) => {
-                if (beta) {
-                    task.title = `Fetching ${packageName} metadata (using beta version)`;
-                }
-                const info = await getNpmTgzInfo(packageName, { beta, version });
-                Object.assign(ctx, info);
-            },
-        },
-        {
-            title: `Downloading ${packageName}`,
-            task: async (ctx, task) => {
-                task.title = `Downloading ${packageName} (v${ctx.version})`;
-                await mkdir(dir, { recursive: true });
-                await downloadAndExtract(ctx.url, dir, { strip: 1 });
-            },
-        },
-        {
-            title: "Installing dependencies",
-            task: async (_, task) => {
-                await installDependencies(dir, {
-                    log: (log) => {
-                        const last = log.split("\n").findLast((i) => !!i);
-                        if (last)
-                            task.output = last;
-                    },
-                });
-                await writeInstallationMetadata(dir, { installedAt: Date.now() });
-            },
-        },
-    ], {
-        rendererOptions: {
-            collapseSubtasks: false,
-            showErrorMessage: false,
-            timer: PRESET_TIMER,
-        },
-    }).run();
-}
-async function installDependencies(dir, { log } = {}) {
-    await new Promise((resolve, reject) => {
-        const child = spawn("npm", ["install", "--omit", "dev", "--verbose", "--legacy-peer-deps"], {
-            cwd: dir,
-            stdio: "pipe",
-            shell: process.platform === "win32",
-        });
-        child.stdout.on("data", (data) => {
-            log?.(data.toString());
-        });
-        let stderr = "";
-        child.stderr.on("data", (data) => {
-            const str = data.toString();
-            log?.(str);
-            stderr += str;
-        });
-        child.on("error", (error) => reject(error));
-        child.on("exit", (code) => {
-            if (code === 0)
-                resolve();
-            else {
-                console.error(stderr);
-                reject(new Error(`npm install failed with code ${code}`));
-            }
-        });
-    });
-}
-export async function getNpmTgzInfo(name, { version, beta } = {}) {
-    const res = await fetch(joinURL("https://registry.npmjs.org", name));
-    const data = await res.json();
-    let targetVersion;
-    if (version) {
-        if (!data.versions[version]) {
-            throw new Error(`Version ${version} of package ${name} not found`);
-        }
-        targetVersion = version;
-    }
-    else if (beta && data["dist-tags"].beta) {
-        // Use beta version if available and beta flag is set
-        targetVersion = data["dist-tags"].beta;
-    }
-    else {
-        // Fall back to latest version
-        targetVersion = data["dist-tags"].latest;
-    }
-    const url = data.versions[targetVersion].dist.tarball;
-    return {
-        version: targetVersion,
-        url,
-    };
-}
-function safeParseJSON(raw) {
-    try {
-        return JSON.parse(raw);
-    }
-    catch { }
-}

package/dist/commands/run.js

@@ -2,7 +2,6 @@ import { cp, mkdir, rm } from "node:fs/promises";
 import { homedir } from "node:os";
 import { isAbsolute, join, resolve } from "node:path";
 import { exists } from "@aigne/agent-library/utils/fs.js";
-import { mapCliAgent } from "@aigne/core/utils/agent-utils.js";
 import { flat, isNonNullable } from "@aigne/core/utils/type-utils.js";
 import { Listr, PRESET_TIMER } from "@aigne/listr2";
 import { config } from "dotenv-flow";
@@ -11,8 +10,7 @@ import { isV1Package, toAIGNEPackage } from "../utils/agent-v1.js";
 import { downloadAndExtract } from "../utils/download.js";
 import { loadAIGNE } from "../utils/load-aigne.js";
 import { isUrl } from "../utils/url.js";
-import { serializeAgent } from "../utils/workers/run-aigne-in-child-process.js";
-import { agentCommandModule, cliAgentCommandModule } from "./app.js";
+import { agentCommandModule, cliAgentCommandModule } from "./app/agent.js";
 export function createRunCommand({ aigneFilePath, } = {}) {
     return {
         command: "run [path] [entry-agent]",
@@ -39,23 +37,23 @@ export function createRunCommand({ aigneFilePath, } = {}) {
                     options.path = undefined;
                 }
             }
-            const { aigne, path } = await loadApplication(aigneFilePath || options.path || ".");
+            const { aigne } = await loadApplication(aigneFilePath || options.path || ".");
             const subYargs = yargs().scriptName("").usage("aigne run <path> <agent> [...options]");
             if (aigne.cli.chat) {
                 subYargs.command({
-                    ...agentCommandModule({ dir: path, agent: serializeAgent(aigne.cli.chat), chat: true }),
+                    ...agentCommandModule({ aigne, agent: aigne.cli.chat, chat: true }),
                     command: "$0",
                 });
             }
             // Allow user to run all of agents in the AIGNE instances
             const allAgents = flat(aigne.agents, aigne.skills, aigne.cli.chat, aigne.mcpServer.agents);
             for (const agent of allAgents) {
-                subYargs.command(agentCommandModule({ dir: path, agent: serializeAgent(agent) }));
+                subYargs.command(agentCommandModule({ aigne, agent }));
             }
             for (const cliAgent of aigne.cli.agents ?? []) {
                 subYargs.command(cliAgentCommandModule({
-                    dir: path,
-                    cliAgent: mapCliAgent(cliAgent, (a) => (a ? serializeAgent(a) : undefined)),
+                    aigne,
+                    cliAgent,
                 }));
             }
             const argv = process.argv.slice(aigneFilePath ? 3 : 2);

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

@@ -1,21 +1,20 @@
-import type { AIGNEMetadata } from "@aigne/core/aigne/type.js";
+import type { AIGNE } from "@aigne/core";
 import type { CommandModule } from "yargs";
 interface ServeMCPOptions {
     path: string;
     host: string;
     port?: number;
     pathname: string;
+    aigneHubUrl?: string;
 }
 export declare const DEFAULT_PORT: () => number;
 export declare function createServeMCPCommand({ aigneFilePath, }?: {
     aigneFilePath?: string;
 }): CommandModule<unknown, ServeMCPOptions>;
 export declare function serveMCPServerFromDir(options: {
-    dir: string;
+    aigne: AIGNE;
     host: string;
     port?: number;
     pathname: string;
-    aigneHubUrl?: string;
-    metadata?: AIGNEMetadata;
 }): Promise<void>;
 export {};

package/dist/commands/serve-mcp.js

@@ -45,22 +45,23 @@ export function createServeMCPCommand({ aigneFilePath, } = {}) {
         handler: async (options) => {
             const path = aigneFilePath || options.path;
             const absolutePath = isAbsolute(path) ? path : resolve(process.cwd(), path);
-            await serveMCPServerFromDir({ ...options, dir: absolutePath });
+            const aigne = await loadAIGNE({
+                path: absolutePath,
+                modelOptions: { aigneHubUrl: options.aigneHubUrl },
+            });
+            await serveMCPServerFromDir({ ...options, aigne });
         },
     };
 }
 export async function serveMCPServerFromDir(options) {
     const port = options.port || DEFAULT_PORT();
-    const aigne = await loadAIGNE({
-        path: options.dir,
-        modelOptions: { aigneHubUrl: options.aigneHubUrl },
-        metadata: options.metadata,
-    });
     await serveMCPServer({
-        aigne,
+        aigne: options.aigne,
         host: options.host,
         port,
         pathname: options.pathname,
     });
     console.log(`MCP server is running on http://${options.host}:${port}${options.pathname}`);
+    if (!process.env.CI && process.env.NODE_ENV !== "test")
+        await new Promise(() => { }); // Keep the server running
 }

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

@@ -1,7 +1,8 @@
 import { fetch } from "@aigne/core/utils/fetch.js";
 import { joinURL } from "ufo";
 export async function getUserInfo({ baseUrl, apiKey, }) {
-    const response = await fetch(joinURL(baseUrl, "/api/user/info"), {
+    const secureBaseUrl = baseUrl.replace(/^http:/, "https:");
+    const response = await fetch(joinURL(secureBaseUrl, "/api/user/info"), {
         headers: { Authorization: `Bearer ${apiKey}` },
     });
     const data = await response.json();

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

@@ -8,11 +8,10 @@ export interface RunOptions extends AgentRunCommonOptions {
     cacheDir?: string;
     aigneHubUrl?: string;
 }
-export declare function loadAIGNE({ path, modelOptions, imageModelOptions, printTips, skipModelLoading, metadata, }: {
+export declare function loadAIGNE({ path, modelOptions, imageModelOptions, skipModelLoading, metadata, }: {
     path?: string;
     modelOptions?: ChatModelInputOptions & LoadCredentialOptions;
     imageModelOptions?: ImageModelInputOptions & LoadCredentialOptions;
-    printTips?: boolean;
     skipModelLoading?: boolean;
     metadata?: AIGNEMetadata;
 }): Promise<AIGNE<import("@aigne/core").UserContext>>;

package/dist/utils/load-aigne.js

@@ -21,7 +21,7 @@ async function printChatModelInfoBox(model) {
     console.log(boxen(lines.join("\n"), { padding: 1, borderStyle: "classic", borderColor: "cyan" }));
     console.log("");
 }
-export async function loadAIGNE({ path, modelOptions, imageModelOptions, printTips = false, skipModelLoading = false, metadata, }) {
+export async function loadAIGNE({ path, modelOptions, imageModelOptions, skipModelLoading = false, metadata, }) {
     let aigne;
     if (path) {
         aigne = await AIGNE.load(path, {
@@ -62,7 +62,7 @@ export async function loadAIGNE({ path, modelOptions, imageModelOptions, printTi
             metadata: { ...metadata, cliVersion: AIGNE_CLI_VERSION },
         });
     }
-    if (printTips && !printed) {
+    if (!skipModelLoading && !printed) {
         printed = true;
         console.log(`${chalk.grey("TIPS:")} run ${chalk.cyan("aigne observe")} to start the observability server.\n`);
         if (aigne.model) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/cli",
-  "version": "1.53.1-beta.2",
+  "version": "1.53.1-beta.4",
   "description": "Your command center for agent development",
   "publishConfig": {
     "access": "public"
@@ -55,7 +55,7 @@
     "@inquirer/type": "^3.0.8",
     "@listr2/prompt-adapter-inquirer": "^3.0.4",
     "@modelcontextprotocol/sdk": "^1.18.0",
-    "@ocap/mcrypto": "^1.26.3",
+    "@ocap/mcrypto": "^1.27.2",
     "@smithy/node-http-handler": "^4.2.1",
     "ansi-escapes": "^7.1.0",
     "ansi-regex": "^6.2.2",
@@ -89,14 +89,14 @@
     "yoctocolors-cjs": "^2.1.3",
     "zod": "^3.25.67",
     "zod-to-json-schema": "^3.24.6",
-    "@aigne/afs-system-fs": "^1.0.4-beta.2",
-    "@aigne/agent-library": "^1.21.51-beta.1",
-    "@aigne/agentic-memory": "^1.0.51-beta.1",
-    "@aigne/core": "^1.65.1-beta.1",
-    "@aigne/aigne-hub": "^0.10.5-beta.1",
-    "@aigne/default-memory": "^1.2.14-beta.1",
-    "@aigne/observability-api": "^0.11.5-beta",
-    "@aigne/openai": "^0.16.5-beta.1"
+    "@aigne/afs-system-fs": "^1.0.4-beta.4",
+    "@aigne/agent-library": "^1.21.51-beta.3",
+    "@aigne/agentic-memory": "^1.0.51-beta.3",
+    "@aigne/aigne-hub": "^0.10.5-beta.3",
+    "@aigne/core": "^1.65.1-beta.3",
+    "@aigne/default-memory": "^1.2.14-beta.3",
+    "@aigne/observability-api": "^0.11.5-beta.2",
+    "@aigne/openai": "^0.16.5-beta.3"
   },
   "devDependencies": {
     "@inquirer/testing": "^2.1.50",
@@ -114,7 +114,7 @@
     "rimraf": "^6.0.1",
     "typescript": "^5.9.2",
     "ufo": "^1.6.1",
-    "@aigne/test-utils": "^0.5.58-beta.1"
+    "@aigne/test-utils": "^0.5.58-beta.3"
   },
   "scripts": {
     "lint": "tsc --noEmit",

package/dist/utils/workers/run-aigne-in-child-process-worker.d.ts

@@ -1,22 +0,0 @@
-import type { Message } from "@aigne/core";
-import type { AIGNEMetadata } from "@aigne/core/aigne/type.js";
-import { loadAIGNE } from "../load-aigne.js";
-import { type AgentRunCommonOptions } from "../yargs.js";
-import { type AgentInChildProcess, type CLIAgentInChildProcess } from "./run-aigne-in-child-process.js";
-export declare function loadAIGNEInChildProcess(options: Parameters<typeof loadAIGNE>[0]): Promise<{
-    agents?: AgentInChildProcess[];
-    cli?: {
-        chat?: AgentInChildProcess;
-        agents?: CLIAgentInChildProcess[];
-    };
-    mcpServer?: {
-        agents?: AgentInChildProcess[];
-    };
-}>;
-export declare function invokeCLIAgentFromDirInChildProcess(options: {
-    dir: string;
-    parent?: string[];
-    agent: string;
-    input: Message & AgentRunCommonOptions;
-    metadata?: AIGNEMetadata;
-}): Promise<void>;