@aigne/cli 1.39.1 → 1.40.0

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [1.40.0](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.39.1...cli-v1.40.0) (2025-08-22)
+
+
+### Features
+
+* **cli:** support aigne deploy command ([#399](https://github.com/AIGNE-io/aigne-framework/issues/399)) ([b69cba9](https://github.com/AIGNE-io/aigne-framework/commit/b69cba901d95882f847032f41d963e2fa6893ab6))
+
 ## [1.39.1](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.39.0...cli-v1.39.1) (2025-08-21)
 
 

package/dist/commands/aigne.js

@@ -3,6 +3,7 @@ import { AIGNE_CLI_VERSION } from "../constants.js";
 import { asciiLogo } from "../utils/ascii-logo.js";
 import { createAppCommands } from "./app.js";
 import { createCreateCommand } from "./create.js";
+import { createDeployCommands } from "./deploy.js";
 import { createHubCommand } from "./hub.js";
 import { createObservabilityCommand } from "./observe.js";
 import { createRunCommand } from "./run.js";
@@ -21,6 +22,7 @@ export function createAIGNECommand(options) {
         .command(createObservabilityCommand())
         .command(createAppCommands())
         .command(createHubCommand())
+        .command(createDeployCommands())
         .demandCommand()
         .alias("help", "h")
         .alias("version", "v")

package/dist/commands/deploy.d.ts

@@ -0,0 +1,11 @@
+import type { CommandModule } from "yargs";
+interface DeployOptions {
+    path?: string;
+    endpoint?: string;
+}
+export declare function fileExists(p: string): Promise<boolean>;
+export declare const DEPLOYED_FILE: string;
+export declare function run(cmd: string, args?: string[], opts?: any): Promise<string>;
+export declare function createDeployCommands(): CommandModule<unknown, DeployOptions>;
+export declare const deploy: (path: string, endpoint: string) => Promise<void>;
+export {};

package/dist/commands/deploy.js

@@ -0,0 +1,254 @@
+import { spawn } from "node:child_process";
+import { constants } from "node:fs";
+import { access, copyFile, mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, isAbsolute, join, resolve } from "node:path";
+import { Listr } from "@aigne/listr2";
+import { input as inputInquirer, select as selectInquirer } from "@inquirer/prompts";
+import { ListrInquirerPromptAdapter } from "@listr2/prompt-adapter-inquirer";
+import { parse, stringify } from "yaml";
+import { isTest } from "../utils/aigne-hub/constants.js";
+export async function fileExists(p) {
+    try {
+        await access(p, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export const DEPLOYED_FILE = isTest ? "deployed.test.yaml" : "deployed.yaml";
+export async function run(cmd, args = [], opts = {}) {
+    return new Promise((resolve, reject) => {
+        const { catchOutput = true, ...rest } = opts;
+        const spawnOpts = { shell: true, ...rest, stdio: catchOutput ? "pipe" : "inherit" };
+        const child = spawn(cmd, args, spawnOpts);
+        if (catchOutput) {
+            let stdout = "";
+            let stderr = "";
+            child.stdout?.on("data", (data) => {
+                stdout += data.toString();
+            });
+            child.stderr?.on("data", (data) => {
+                stderr += data.toString();
+            });
+            child.on("close", (code) => {
+                if (code === 0) {
+                    resolve(stdout.trim());
+                }
+                else {
+                    reject(new Error(stderr.trim() || `Process failed with code ${code}`));
+                }
+            });
+        }
+        else {
+            child.on("close", (code) => {
+                if (code === 0) {
+                    resolve("");
+                }
+                else {
+                    reject(new Error(`${cmd} ${args.join(" ")} failed with code ${code}`));
+                }
+            });
+        }
+    });
+}
+export function createDeployCommands() {
+    return {
+        command: "deploy",
+        describe: "Deploy an aigne application",
+        builder: (yargs) => {
+            return yargs
+                .option("path", {
+                type: "string",
+            })
+                .option("endpoint", {
+                type: "string",
+                describe: "Deploy an aigne application to a specified endpoint.",
+            });
+        },
+        handler: async (argv) => {
+            const path = argv.path;
+            const endpoint = argv.endpoint;
+            if (!path) {
+                console.error("path is required");
+                process.exit(1);
+            }
+            if (!endpoint) {
+                console.error("endpoint is required");
+                process.exit(1);
+            }
+            const absolutePath = isAbsolute(path) ? path : resolve(process.cwd(), path);
+            await deploy(absolutePath, endpoint);
+        },
+    };
+}
+async function copyDir(src, dest) {
+    await mkdir(dest, { recursive: true });
+    const entries = await readdir(src, { withFileTypes: true });
+    const skip = [".deploy", "node_modules"];
+    for (const entry of entries) {
+        const srcPath = join(src, entry.name);
+        const destPath = join(dest, entry.name);
+        if (skip.includes(entry.name))
+            continue;
+        if (entry.isDirectory()) {
+            await copyDir(srcPath, destPath);
+        }
+        else {
+            await copyFile(srcPath, destPath);
+        }
+    }
+}
+export const deploy = async (path, endpoint) => {
+    const aigneHomeDir = join(homedir(), ".aigne");
+    if (!(await fileExists(aigneHomeDir))) {
+        await mkdir(aigneHomeDir, { recursive: true });
+    }
+    const deployRoot = join(path, ".deploy");
+    const agentDest = join(deployRoot, "agent");
+    const tasks = new Listr([
+        {
+            title: "Prepare deploy environment",
+            task: async (ctx, task) => {
+                ctx.logs = [];
+                task.output = "Preparing deploy environment...";
+                const entryFile = join(path, "aigne.yaml");
+                if (!(await fileExists(entryFile))) {
+                    throw new Error(`Entry file not found: ${entryFile}`);
+                }
+                await rm(deployRoot, { recursive: true, force: true });
+                task.output = "Copying template files...";
+                const templatePath = join(import.meta.dirname, "../../templates/blocklet");
+                await copyDir(templatePath, deployRoot);
+                await copyDir(path, agentDest);
+                const specialFiles = [
+                    "package.json",
+                    "package-lock.json",
+                    "README.md",
+                    "CHANGELOG.md",
+                    "biome.json",
+                ];
+                for (const file of specialFiles) {
+                    const srcFile = join(path, file);
+                    if (await fileExists(srcFile)) {
+                        await copyFile(srcFile, join(deployRoot, file));
+                        await rm(join(deployRoot, file), { force: true });
+                    }
+                }
+                if (await fileExists(join(deployRoot, "package.json"))) {
+                    task.output = "Running npm install...";
+                    await run("npm", ["install"], { cwd: deployRoot });
+                }
+            },
+        },
+        {
+            title: "Check Blocklet CLI",
+            task: async (_, task) => {
+                try {
+                    task.output = "Checking Blocklet CLI Version...";
+                    await run("blocklet", ["--version"], { cwd: deployRoot });
+                }
+                catch {
+                    task.output = "Blocklet CLI not installed, asking to install...";
+                    const { install } = await task
+                        .prompt(ListrInquirerPromptAdapter)
+                        .run(selectInquirer, {
+                        type: "list",
+                        name: "install",
+                        message: "Install Blocklet CLI?",
+                        choices: ["yes", "no"],
+                        default: "yes",
+                    });
+                    if (install === "yes") {
+                        task.output = "Installing Blocklet CLI...";
+                        await run("npm", ["install", "-g", "@blocklet/cli"], { cwd: deployRoot });
+                    }
+                    else {
+                        throw new Error("Blocklet CLI not found, please install manually: npm install -g @blocklet/cli");
+                    }
+                }
+            },
+        },
+        {
+            title: "Configure Blocklet",
+            task: async (ctx, task) => {
+                task.output = "Configuring Blocklet...";
+                if (await fileExists(join(deployRoot, "blocklet.yml"))) {
+                    const entryFile = join(path, "aigne.yaml");
+                    const aigneFile = await readFile(entryFile, "utf-8");
+                    const aigneData = parse(aigneFile);
+                    const agentName = aigneData.name;
+                    const deployed = parse(await readFile(join(aigneHomeDir, DEPLOYED_FILE), "utf-8").catch(() => stringify({})));
+                    let blockletName = deployed[path]?.name;
+                    if (!blockletName) {
+                        task.output = "Asking for Blocklet name...";
+                        blockletName = await task
+                            .prompt(ListrInquirerPromptAdapter)
+                            .run(inputInquirer, {
+                            type: "input",
+                            name: "blockletName",
+                            message: "Please input agent blocklet name:",
+                            default: deployed[path]?.name || agentName || basename(path),
+                            validate: (input) => {
+                                if (input.trim() === "")
+                                    return "Blocklet name cannot be empty.";
+                                return true;
+                            },
+                        });
+                    }
+                    let did = deployed[path]?.did;
+                    if (!did) {
+                        task.output = "Creating DID...";
+                        const info = await run("blocklet", ["create", "--did-only"], {
+                            cwd: deployRoot,
+                            catchOutput: true,
+                        });
+                        const match = info.match(/Created Blocklet DID:\s+(\S+)/);
+                        if (match?.[1]) {
+                            did = match[1];
+                        }
+                        else {
+                            throw new Error(`DID not found. Output content: ${info}`);
+                        }
+                    }
+                    task.output = `Blocklet name: ${blockletName}, DID: ${did}`;
+                    ctx.logs.push(task.output);
+                    const yml = await readFile(join(deployRoot, "blocklet.yml"), "utf-8");
+                    const data = parse(yml);
+                    data.name = blockletName;
+                    data.title = blockletName;
+                    data.did = did;
+                    await writeFile(join(deployRoot, "blocklet.yml"), stringify(data));
+                    await writeFile(join(aigneHomeDir, DEPLOYED_FILE), stringify({ ...deployed, [path]: { name: blockletName, did } }));
+                }
+            },
+        },
+        {
+            title: "Bundle Blocklet",
+            task: async (_, task) => {
+                task.output = "Running blocklet bundle...";
+                await run("blocklet", ["bundle", "--create-release"], { cwd: deployRoot });
+            },
+        },
+    ], {
+        concurrent: false,
+        exitOnError: true,
+        rendererOptions: {
+            collapseSubtasks: false,
+        },
+    });
+    try {
+        await tasks.run();
+        await run("blocklet", ["deploy", "--endpoint", endpoint, ".blocklet/bundle"], {
+            cwd: deployRoot,
+            catchOutput: false,
+        });
+        await rm(deployRoot, { recursive: true, force: true });
+        console.log(`✅ Deploy completed: ${path} -> ${endpoint}`);
+    }
+    catch (error) {
+        console.error(`❌ Deploy failed: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/cli",
-  "version": "1.39.1",
+  "version": "1.40.0",
   "description": "Your command center for agent development",
   "publishConfig": {
     "access": "public"
@@ -76,10 +76,10 @@
     "yargs": "^18.0.0",
     "zod": "^3.25.67",
     "@aigne/agent-library": "^1.21.26",
+    "@aigne/aigne-hub": "^0.6.8",
     "@aigne/agentic-memory": "^1.0.26",
     "@aigne/core": "^1.55.0",
     "@aigne/default-memory": "^1.1.8",
-    "@aigne/aigne-hub": "^0.6.8",
     "@aigne/observability-api": "^0.10.0",
     "@aigne/openai": "^0.12.2"
   },

package/templates/blocklet/blocklet.md

@@ -0,0 +1,25 @@
+# AIGNE Runtime Blocklet
+
+This project is packaged as a Blocklet agent application.
+
+## Quick Start
+
+### Install AIGNE CLI
+
+```bash
+npm install -g aigne
+```
+
+### Start the Project
+
+```bash
+aigne run agent
+```
+
+## Testing
+
+Run the following command to execute test cases:
+
+```bash
+aigne test
+```

package/templates/blocklet/blocklet.yml

@@ -0,0 +1,57 @@
+name: agent-blocklet
+title: Agent Blocklet
+version: 0.0.1
+description: AIGNE Runtime is a specialized runtime engine designed for executing AI agents, serving as the core runtime environment for the Blocklet system
+files:
+  - agent/
+  - logo.png
+  - blocklet.yml
+  - blocklet.md
+keywords:
+  - aigne
+  - agent
+  - blocklet
+author:
+  name: wangshijun
+  email: wangshijun2010@gmail.com
+  url: http://github.com/wangshijun
+license: MIT
+main: agent
+logo: logo.png
+community: ''
+documentation: ''
+homepage: ''
+environments: []
+specVersion: 1.2.8
+interfaces:
+  - type: web
+    name: publicUrl
+    path: /
+    prefix: '*'
+    port: BLOCKLET_PORT
+    protocol: tcp
+did: ""
+engine:
+  interpreter: blocklet
+  source:
+    store: https://store.blocklet.dev
+    name: z2qa6yt75HHQL3cS4ao7j2aqVodExoBAN7xeS
+    version: latest
+  args: []
+timeout:
+  start: 10
+payment:
+  price: []
+  share: []
+requirements:
+  abtnode: '>=1.1.0'
+  os: '*'
+  cpu: '*'
+scripts:
+  dev: blocklet dev
+capabilities:
+  clusterMode: false
+  component: true
+  navigation: true
+components: []
+