@aigne/cli 1.59.0-beta.9 → 1.59.1-beta

package/dist/commands/aigne.js

@@ -8,6 +8,7 @@ import { createEvalCommand } from "./eval.js";
 import { createHubCommand } from "./hub.js";
 import { createObservabilityCommand } from "./observe.js";
 import { createRunCommand } from "./run.js";
+import { createRunSkillCommand } from "./run-skill.js";
 import { createServeMCPCommand } from "./serve-mcp.js";
 import { createTestCommand } from "./test.js";
 export function createAIGNECommand(options) {
@@ -17,6 +18,7 @@ export function createAIGNECommand(options) {
         .version(AIGNE_CLI_VERSION)
         // default command: when user runs `aigne` without subcommand, behave like `aigne run`
         .command(createRunCommand(options))
+        .command(createRunSkillCommand())
         .command(createEvalCommand(options))
         .command(createTestCommand(options))
         .command(createCreateCommand())

package/dist/commands/app/agent.d.ts

@@ -10,10 +10,10 @@ export declare const serveMcpCommandModule: ({ aigne, name, }: {
     port?: number;
     pathname: string;
 }>;
-export declare const agentCommandModule: ({ aigne, agent, chat, }: {
+export declare const agentCommandModule: ({ aigne, agent, interactive, }: {
     aigne: AIGNE;
     agent: Agent;
-    chat?: boolean;
+    interactive?: boolean;
 }) => CommandModule<unknown, AgentRunCommonOptions>;
 export declare const cliAgentCommandModule: ({ aigne, cliAgent, }: {
     aigne: AIGNE;

package/dist/commands/app/agent.js

@@ -1,4 +1,5 @@
 import assert from "node:assert";
+import { DEFAULT_USER_ID } from "@aigne/cli/constants.js";
 import { logger } from "@aigne/core/utils/logger.js";
 import { v7 } from "@aigne/uuid";
 import { runAgentWithAIGNE } from "../../utils/run-with-aigne.js";
@@ -31,7 +32,7 @@ export const serveMcpCommandModule = ({ aigne, name, }) => ({
         });
     },
 });
-export const agentCommandModule = ({ aigne, agent, chat, }) => {
+export const agentCommandModule = ({ aigne, agent, interactive, }) => {
     return {
         command: agent.name,
         aliases: agent.alias || [],
@@ -39,7 +40,9 @@ export const agentCommandModule = ({ aigne, agent, chat, }) => {
         builder: async (yargs) => {
             return withAgentInputSchema(yargs, {
                 inputSchema: agent.inputSchema,
-                optionalInputs: chat && "inputKey" in agent && typeof agent.inputKey === "string" ? [agent.inputKey] : [],
+                optionalInputs: interactive && "inputKey" in agent && typeof agent.inputKey === "string"
+                    ? [agent.inputKey]
+                    : [],
             });
         },
         handler: async (options) => {
@@ -48,7 +51,7 @@ export const agentCommandModule = ({ aigne, agent, chat, }) => {
             await invokeAgent({
                 aigne,
                 agent,
-                input: { ...options, chat: chat ?? options.chat },
+                input: { ...options, interactive: interactive ?? options.interactive },
             });
         },
     };
@@ -97,8 +100,9 @@ export async function invokeAgent(options) {
         await runAgentWithAIGNE(aigne, agent, {
             ...options.input,
             input,
-            chat: options.input.chat,
-            sessionId: v7(),
+            interactive: options.input.interactive,
+            sessionId: options.input.sessionId || v7(),
+            userId: DEFAULT_USER_ID,
         });
     }
     finally {

package/dist/commands/app/app.js

@@ -38,7 +38,7 @@ export async function runAppCLI({ appName = process.env.AIGNE_APP_NAME, appPacka
                     ...agentCommandModule({
                         aigne,
                         agent: aigne.cli.chat,
-                        chat: true,
+                        interactive: true,
                     }),
                     command: "$0",
                 });

package/dist/commands/run-skill.d.ts

@@ -0,0 +1,6 @@
+import type { CommandModule } from "yargs";
+import { type AgentRunCommonOptions } from "../utils/yargs.js";
+export declare function createRunSkillCommand(): CommandModule<unknown, {
+    skill?: string[];
+    interactive?: boolean;
+} & AgentRunCommonOptions>;

package/dist/commands/run-skill.js

@@ -0,0 +1,102 @@
+import { basename, resolve } from "node:path";
+import { AFSHistory } from "@aigne/afs-history";
+import { LocalFS } from "@aigne/afs-local-fs";
+import AgentSkillManager from "@aigne/agent-library/agent-skill-manager";
+import AskUserQuestion from "@aigne/agent-library/ask-user-question";
+import BashAgent from "@aigne/agent-library/bash";
+import { AIGNE, FunctionAgent } from "@aigne/core";
+import { z } from "zod";
+import { loadChatModel } from "../utils/aigne-hub/model.js";
+import { withAgentInputSchema } from "../utils/yargs.js";
+import { invokeAgent } from "./app/agent.js";
+export function createRunSkillCommand() {
+    return {
+        command: ["run-skill"],
+        describe: "Run Agent Skill for the specified path",
+        builder: async (yargs) => {
+            return withAgentInputSchema(yargs
+                .option("skill", {
+                array: true,
+                type: "string",
+                describe: "Path to the Agent Skill directory",
+            })
+                .option("interactive", {
+                describe: "Run in interactive chat mode",
+                type: "boolean",
+                default: false,
+                alias: ["chat"],
+            })
+                .demandOption("skill"), {
+                inputSchema: z.object({
+                    message: z.string(),
+                }),
+                optionalInputs: ["message"],
+            });
+        },
+        handler: async (options) => {
+            if (!Array.isArray(options.skill) || options.skill.length === 0) {
+                throw new Error("At least one skill path must be provided.");
+            }
+            const model = await loadChatModel({
+                model: options.model || "aignehub/anthropic/claude-sonnet-4-5",
+            });
+            const aigne = new AIGNE({ model });
+            const approvedCmds = new Set();
+            const agent = new AgentSkillManager({
+                inputKey: "message",
+                taskRenderMode: "collapse",
+                skills: [
+                    new BashAgent({
+                        sandbox: false,
+                        permissions: {
+                            defaultMode: "ask",
+                            guard: FunctionAgent.from(async (input, options) => {
+                                if (approvedCmds.has(input.script || "")) {
+                                    return {
+                                        approved: true,
+                                    };
+                                }
+                                const confirm = options.prompts?.confirm;
+                                if (!confirm)
+                                    throw new Error("No confirm prompt available for permission guard.");
+                                const approved = await confirm({ message: `Run command ${input.script}?` });
+                                if (approved && input.script) {
+                                    approvedCmds.add(input.script);
+                                }
+                                return {
+                                    approved,
+                                };
+                            }),
+                        },
+                    }),
+                    new AskUserQuestion(),
+                ],
+                afs: {
+                    modules: [
+                        new AFSHistory({}),
+                        new LocalFS({
+                            name: "workspace",
+                            localPath: process.cwd(),
+                            description: `\
+Current working directory. All temporary files should be written here using absolute AFS paths (e.g., /modules/workspace/temp.py).
+Note: Bash is already running in this directory, so do NOT use 'cd /modules/workspace' in scripts. Use relative paths directly (e.g., python temp.py).`,
+                        }),
+                        ...options.skill.map((path) => new LocalFS({
+                            name: basename(resolve(path)),
+                            localPath: path,
+                            description: "Contains Agent Skills. Use 'Skill' tool to invoke skills from this module.",
+                            agentSkills: true,
+                        })),
+                    ],
+                },
+            });
+            await invokeAgent({
+                aigne,
+                agent,
+                input: {
+                    ...options,
+                },
+            });
+        },
+    };
+}

package/dist/commands/run.d.ts

@@ -5,5 +5,5 @@ export declare function createRunCommand({ aigneFilePath, }?: {
     version?: boolean;
     path?: string;
     entryAgent?: string;
-    chat?: boolean;
+    interactive?: boolean;
 }>;

package/dist/commands/run.js

@@ -38,10 +38,11 @@ export function createRunCommand({ aigneFilePath, } = {}) {
                 alias: "v",
                 describe: "Show version number",
             })
-                .option("chat", {
-                describe: "Run chat loop in terminal",
+                .option("interactive", {
+                describe: "Run in interactive chat mode",
                 type: "boolean",
                 default: false,
+                alias: ["chat"],
             })
                 .help(false)
                 .version(false)
@@ -60,15 +61,16 @@ export function createRunCommand({ aigneFilePath, } = {}) {
                 }
             }
             const path = aigneFilePath || options.path || ".";
-            if (!(await findAIGNEFile(path).catch((error) => {
-                if (options._[0] !== "run") {
-                    yargsInstance?.showHelp();
-                }
-                else {
-                    throw error;
-                }
-                return false;
-            }))) {
+            if (!isUrl(path) &&
+                !(await findAIGNEFile(path).catch((error) => {
+                    if (options._[0] !== "run") {
+                        yargsInstance?.showHelp();
+                    }
+                    else {
+                        throw error;
+                    }
+                    return false;
+                }))) {
                 return;
             }
             // Parse model options for loading application
@@ -81,14 +83,14 @@ export function createRunCommand({ aigneFilePath, } = {}) {
             const subYargs = yargs().scriptName("").usage("aigne run <path> <agent> [...options]");
             if (aigne.cli.chat) {
                 subYargs.command({
-                    ...agentCommandModule({ aigne, agent: aigne.cli.chat, chat: true }),
+                    ...agentCommandModule({ aigne, agent: aigne.cli.chat, interactive: 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({ aigne, agent, chat: options.chat }));
+                subYargs.command(agentCommandModule({ aigne, agent, interactive: options.interactive }));
             }
             for (const cliAgent of aigne.cli.agents ?? []) {
                 subYargs.command(cliAgentCommandModule({

package/dist/constants.d.ts

@@ -3,3 +3,5 @@ export declare const AIGNE_CLI_VERSION: any;
 export declare const availableMemories: (typeof DefaultMemory)[];
 export declare const AIGNE_HUB_CREDITS_NOT_ENOUGH_ERROR_TYPE = "NOT_ENOUGH";
 export declare const CHAT_MODEL_OPTIONS: string[];
+export declare const DEFAULT_USER_ID = "cli-user";
+export declare const DEFAULT_AFS_EXPLORER_PORT = 9670;

package/dist/constants.js

@@ -17,3 +17,5 @@ export const CHAT_MODEL_OPTIONS = [
     "preferInputFileType",
     "reasoningEffort",
 ];
+export const DEFAULT_USER_ID = "cli-user";
+export const DEFAULT_AFS_EXPLORER_PORT = 9670;

package/dist/tracer/terminal.js

@@ -154,6 +154,7 @@ export class TerminalTracer {
             }
             task.resolve();
         };
+        let retryPromptPromise;
         const onError = async ({ context, agent, error, ...event }) => {
             if ("type" in error && error.type === AIGNE_HUB_CREDITS_NOT_ENOUGH_ERROR_TYPE) {
                 if (!Object.hasOwn(error, CREDITS_ERROR_PROCESSED_FLAG)) {
@@ -168,6 +169,23 @@ export class TerminalTracer {
                     }
                 }
             }
+            if (agent instanceof ChatModel) {
+                retryPromptPromise ??= this.proxiedPrompts
+                    .select({
+                    message: chalk.red(`Error: ${error.message}`),
+                    choices: [
+                        { value: "retry", name: "Retry" },
+                        { value: "exit", name: "Exit" },
+                    ],
+                })
+                    .then((result) => ({ retry: result === "retry" }))
+                    .finally(() => {
+                    retryPromptPromise = undefined;
+                });
+                const { retry } = await retryPromptPromise;
+                if (retry)
+                    return { retry: true };
+            }
             const contextId = context.id;
             const task = this.tasks[contextId];
             if (!task)

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

@@ -9,9 +9,6 @@ export declare function createConnect({ connectUrl, openPage, fetchInterval, ret
 export declare function connectToAIGNEHub(url: string): Promise<{
     apiKey: string;
     url: string;
-} | {
-    apiKey: undefined;
-    url: undefined;
 }>;
 export declare const checkConnectionStatus: (host: string) => Promise<{
     apiKey: any;

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

@@ -3,7 +3,6 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { AIGNE_HUB_BLOCKLET_DID, AIGNE_HUB_URL, getAIGNEHubMountPoint } from "@aigne/aigne-hub";
 import { fetch } from "@aigne/core/utils/fetch.js";
-import { logger } from "@aigne/core/utils/logger.js";
 import inquirer from "inquirer";
 import open from "open";
 import pWaitFor from "p-wait-for";
@@ -38,7 +37,7 @@ export const fetchConfigs = async ({ connectUrl, sessionId, fetchInterval, fetch
     };
 };
 function baseWrapSpinner(_, waiting) {
-    return Promise.resolve(waiting());
+    return 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", }) {
     const startSessionURL = joinURL(connectUrl, ACCESS_KEY_SESSION_API);
@@ -68,28 +67,22 @@ export async function connectToAIGNEHub(url) {
     const { origin } = new URL(url);
     const connectUrl = joinURL(origin, WELLKNOWN_SERVICE_PATH_PREFIX);
     const apiUrl = await getAIGNEHubMountPoint(url, AIGNE_HUB_BLOCKLET_DID);
-    try {
-        const openFn = isTest ? () => { } : open;
-        const result = await createConnect({
-            connectUrl: connectUrl,
-            connectAction: "gen-simple-access-key",
-            source: `@aigne/cli connect to AIGNE hub`,
-            closeOnSuccess: true,
-            openPage: (pageUrl) => openFn(pageUrl),
-        });
-        const accessKeyOptions = {
-            apiKey: result.accessKeySecret,
-            url: apiUrl,
-        };
-        const secretStore = await getSecretStore();
-        await secretStore.setKey(accessKeyOptions.url, accessKeyOptions.apiKey);
-        await secretStore.setDefault(accessKeyOptions.url);
-        return accessKeyOptions;
-    }
-    catch (error) {
-        logger.error("Failed to connect to AIGNE Hub", error.message);
-        return { apiKey: undefined, url: undefined };
-    }
+    const openFn = isTest ? () => { } : open;
+    const result = await createConnect({
+        connectUrl: connectUrl,
+        connectAction: "gen-simple-access-key",
+        source: `@aigne/cli connect to AIGNE hub`,
+        closeOnSuccess: true,
+        openPage: (pageUrl) => openFn(pageUrl),
+    });
+    const accessKeyOptions = {
+        apiKey: result.accessKeySecret,
+        url: apiUrl,
+    };
+    const secretStore = await getSecretStore();
+    await secretStore.setKey(accessKeyOptions.url, accessKeyOptions.apiKey);
+    await secretStore.setDefault(accessKeyOptions.url);
+    return accessKeyOptions;
 }
 export const checkConnectionStatus = async (host) => {
     const secretStore = await getSecretStore();

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

@@ -1,5 +1,26 @@
 import crypto from "node:crypto";
-import { AesCrypter } from "@ocap/mcrypto/lib/crypter/aes-legacy.js";
+import AES from "crypto-js/aes.js";
+import encBase64 from "crypto-js/enc-base64.js";
+import encHex from "crypto-js/enc-hex.js";
+import encLatin1 from "crypto-js/enc-latin1.js";
+import encUtf8 from "crypto-js/enc-utf8.js";
+import encUtf16 from "crypto-js/enc-utf16.js";
+const encoders = {
+    latin1: encLatin1,
+    utf8: encUtf8,
+    hex: encHex,
+    utf16: encUtf16,
+    base64: encBase64,
+};
+class AesCrypter {
+    encrypt(message, secret) {
+        const text = typeof message === "string" ? message : JSON.stringify(message);
+        return AES.encrypt(text, secret).toString();
+    }
+    decrypt(cipher, secret, outputEncoding = "utf8") {
+        return AES.decrypt(cipher, secret).toString(encoders[outputEncoding]);
+    }
+}
 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"));

package/dist/utils/aigne-hub/store/index.d.ts

@@ -1,4 +1,5 @@
 import FileStore from "./file.js";
 import KeyringStore from "./keytar.js";
 declare const getSecretStore: () => Promise<FileStore | KeyringStore>;
+export declare const resetSecretStoreCache: () => void;
 export default getSecretStore;

package/dist/utils/aigne-hub/store/index.js

@@ -1,5 +1,5 @@
 import { logger } from "@aigne/core/utils/logger.js";
-import { AIGNE_ENV_FILE } from "../constants.js";
+import { AIGNE_ENV_FILE, isTest } from "../constants.js";
 import FileStore from "./file.js";
 import KeyringStore from "./keytar.js";
 import { migrateFileToKeyring } from "./migrate.js";
@@ -32,9 +32,12 @@ const getSecretStore = async () => {
         cachedSecretStore = await createSecretStore({
             filepath: AIGNE_ENV_FILE,
             serviceName: "aigne-hub",
-            // forceKeytarUnavailable: true,
+            forceKeytarUnavailable: Boolean(isTest),
         });
     }
     return cachedSecretStore;
 };
+export const resetSecretStoreCache = () => {
+    cachedSecretStore = undefined;
+};
 export default getSecretStore;

package/dist/utils/inquirer/checkbox.js

@@ -153,7 +153,6 @@ export default createPrompt((config, done) => {
                 let next = active;
                 do {
                     next = (next + offset + items.length) % items.length;
-                    // biome-ignore lint/style/noNonNullAssertion: we need to access items dynamically
                 } while (!isSelectable(items[next]));
                 setActive(next);
             }

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

@@ -1,4 +1,4 @@
-import { AIGNE, type ChatModelInputOptions, type ImageModelInputOptions } from "@aigne/core";
+import { AIGNE, type ChatModel, type ChatModelInputOptions, type ImageModelInputOptions } from "@aigne/core";
 import type { AIGNEMetadata } from "@aigne/core/aigne/type.js";
 import type { LoadCredentialOptions } from "./aigne-hub/type.js";
 import type { AgentRunCommonOptions } from "./yargs.js";
@@ -8,6 +8,7 @@ export interface RunOptions extends AgentRunCommonOptions {
     cacheDir?: string;
     aigneHubUrl?: string;
 }
+export declare function printChatModelInfoBox(model: ChatModel, otherLines?: string[]): Promise<void>;
 export declare function loadAIGNE({ path, modelOptions, imageModelOptions, skipModelLoading, metadata, }: {
     path?: string;
     modelOptions?: ChatModelInputOptions & LoadCredentialOptions;

package/dist/utils/load-aigne.js

@@ -6,8 +6,8 @@ import chalk from "chalk";
 import { AIGNE_CLI_VERSION, availableMemories } from "../constants.js";
 import { loadChatModel, loadImageModel, maskApiKey } from "./aigne-hub/model.js";
 import { getUrlOrigin } from "./get-url-origin.js";
-let printed = false;
-async function printChatModelInfoBox(model) {
+export async function printChatModelInfoBox(model, otherLines) {
+    console.log(`${chalk.grey("TIPS:")} run ${chalk.cyan("aigne observe")} to start the observability server.\n`);
     const credential = await model.credential;
     const lines = [`${chalk.cyan("Provider")}: ${chalk.green(model.name.replace("ChatModel", ""))}`];
     if (credential?.model) {
@@ -19,6 +19,8 @@ async function printChatModelInfoBox(model) {
     if (credential?.apiKey) {
         lines.push(`${chalk.cyan("API Key")}: ${chalk.green(maskApiKey(credential?.apiKey))}`);
     }
+    if (otherLines?.length)
+        lines.push(...otherLines);
     console.log(boxen(lines.join("\n"), { padding: 1, borderStyle: "classic", borderColor: "cyan" }));
     console.log("");
 }
@@ -55,7 +57,7 @@ export async function loadAIGNE({ path, modelOptions, imageModelOptions, skipMod
                 availableModules: [
                     {
                         module: "history",
-                        load: (options) => import("@aigne/afs-history").then((m) => new m.AFSHistory(options.parsed)),
+                        load: (options) => import("@aigne/afs-history").then((m) => m.AFSHistory.load(options)),
                     },
                     {
                         module: "local-fs",
@@ -74,12 +76,5 @@ export async function loadAIGNE({ path, modelOptions, imageModelOptions, skipMod
             metadata: { ...metadata, cliVersion: AIGNE_CLI_VERSION },
         });
     }
-    if (!skipModelLoading && !printed) {
-        printed = true;
-        console.log(`${chalk.grey("TIPS:")} run ${chalk.cyan("aigne observe")} to start the observability server.\n`);
-        if (aigne.model) {
-            await printChatModelInfoBox(aigne.model);
-        }
-    }
     return aigne;
 }

package/dist/utils/run-chat-loop.d.ts

@@ -1,6 +1,7 @@
 import { type Message, type UserAgent } from "@aigne/core";
 export declare const DEFAULT_CHAT_INPUT_KEY = "message";
 export interface ChatLoopOptions {
+    userId?: string;
     sessionId?: string;
     initialCall?: Message | string;
     welcome?: string;

package/dist/utils/run-chat-loop.js

@@ -7,8 +7,6 @@ import { terminalInput } from "../ui/utils/terminal-input.js";
 export const DEFAULT_CHAT_INPUT_KEY = "message";
 export async function runChatLoopInTerminal(userAgent, options = {}) {
     const { initialCall } = options;
-    if (options?.welcome)
-        console.log(options.welcome);
     if (initialCall) {
         await callAgent(userAgent, initialCall, options);
         if (options.input && options.inputFileKey) {
@@ -75,7 +73,7 @@ async function callAgent(userAgent, input, options) {
     const tracer = new TerminalTracer(userAgent.context, options);
     await tracer.run(userAgent, typeof input === "string"
         ? { ...options.input, [options.inputKey || DEFAULT_CHAT_INPUT_KEY]: input }
-        : { ...options.input, ...input }, { userContext: { sessionId: options.sessionId } });
+        : { ...options.input, ...input }, { userContext: { sessionId: options.sessionId, userId: options.userId } });
 }
 const COMMANDS = {
     "/exit": () => ({ exit: true }),

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

@@ -15,7 +15,8 @@ export declare function runWithAIGNE(agentCreator: ((aigne: AIGNE) => PromiseOrV
     modelOptions?: ChatModelInputOptions;
     outputKey?: string;
 }): Promise<void>;
-export declare function runAgentWithAIGNE(aigne: AIGNE, agent: Agent, { sessionId, outputKey, outputFileKey, chatLoopOptions, ...options }?: {
+export declare function runAgentWithAIGNE(aigne: AIGNE, agent: Agent, { userId, sessionId, outputKey, outputFileKey, chatLoopOptions, ...options }?: {
+    userId?: string;
     sessionId?: string;
     outputKey?: string;
     outputFileKey?: string;

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

@@ -1,15 +1,20 @@
 import { mkdir, stat, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join } from "node:path";
 import { isatty } from "node:tty";
+import { fileURLToPath } from "node:url";
+import { startExplorer } from "@aigne/afs-explorer";
 import { exists } from "@aigne/agent-library/utils/fs.js";
 import { AIAgent, DEFAULT_OUTPUT_KEY, UserAgent, } from "@aigne/core";
 import { logger } from "@aigne/core/utils/logger.js";
 import { isEmpty, isNil, omitBy, pick } from "@aigne/core/utils/type-utils.js";
+import { v7 } from "@aigne/uuid";
 import chalk from "chalk";
+import { detect } from "detect-port";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
+import { DEFAULT_AFS_EXPLORER_PORT, DEFAULT_USER_ID } from "../constants.js";
 import { TerminalTracer } from "../tracer/terminal.js";
-import { loadAIGNE } from "./load-aigne.js";
+import { loadAIGNE, printChatModelInfoBox } from "./load-aigne.js";
 import { DEFAULT_CHAT_INPUT_KEY, runChatLoopInTerminal, } from "./run-chat-loop.js";
 import { parseAgentInput, withAgentInputSchema, withRunAgentCommonOptions, } from "./yargs.js";
 export async function parseAgentInputByCommander(agent, options = {}) {
@@ -52,6 +57,8 @@ export async function runWithAIGNE(agentCreator, { aigne, argv = process.argv, c
                 ...omitBy(pick(options, "model", "temperature", "topP", "presencePenalty", "frequencyPenalty"), (v) => isNil(v)),
             },
         });
+        let explorerServer;
+        let explorerServerURL;
         try {
             const agent = typeof agentCreator === "function" ? await agentCreator(aigne) : agentCreator;
             const input = await parseAgentInputByCommander(agent, {
@@ -59,14 +66,34 @@ export async function runWithAIGNE(agentCreator, { aigne, argv = process.argv, c
                 inputKey: chatLoopOptions?.inputKey,
                 defaultInput: chatLoopOptions?.initialCall || chatLoopOptions?.defaultQuestion,
             });
+            if (agent.afs) {
+                const port = await detect(DEFAULT_AFS_EXPLORER_PORT);
+                explorerServer = await startExplorer(agent.afs, {
+                    port,
+                    distPath: dirname(fileURLToPath(import.meta.resolve("@aigne/afs-explorer/index.html"))),
+                });
+                explorerServerURL = `http://localhost:${port}`;
+            }
+            if (aigne.model) {
+                const lines = [];
+                if (explorerServerURL) {
+                    lines.push(`${chalk.cyan("AFS Explorer")}: ${chalk.green(explorerServerURL)}`);
+                }
+                await printChatModelInfoBox(aigne.model, lines);
+            }
+            if (chatLoopOptions?.welcome)
+                console.log(chatLoopOptions.welcome);
             await runAgentWithAIGNE(aigne, agent, {
                 ...options,
                 outputKey: outputKey || options.outputKey,
                 chatLoopOptions,
                 input,
+                sessionId: chatLoopOptions?.sessionId || v7(),
+                userId: DEFAULT_USER_ID,
             });
         }
         finally {
+            await explorerServer?.stop();
             await aigne.shutdown();
         }
     })
@@ -84,7 +111,7 @@ export async function runWithAIGNE(agentCreator, { aigne, argv = process.argv, c
         process.exit(1);
     });
 }
-export async function runAgentWithAIGNE(aigne, agent, { sessionId, outputKey, outputFileKey, chatLoopOptions, ...options } = {}) {
+export async function runAgentWithAIGNE(aigne, agent, { userId, sessionId, outputKey, outputFileKey, chatLoopOptions, ...options } = {}) {
     if (options.output) {
         const outputPath = isAbsolute(options.output)
             ? options.output
@@ -102,9 +129,9 @@ export async function runAgentWithAIGNE(aigne, agent, { sessionId, outputKey, ou
         }
         await writeFile(outputPath, "", "utf8");
     }
-    if (options.chat) {
+    if (options.interactive) {
         if (!isatty(process.stdout.fd)) {
-            throw new Error("--chat mode requires a TTY terminal");
+            throw new Error("--interactive mode requires a TTY terminal");
         }
         const userAgent = agent instanceof UserAgent ? agent : aigne.invoke(agent);
         await runChatLoopInTerminal(userAgent, {
@@ -113,6 +140,7 @@ export async function runAgentWithAIGNE(aigne, agent, { sessionId, outputKey, ou
             inputFileKey: agent instanceof AIAgent ? agent.inputFileKey : undefined,
             input: options.input,
             sessionId,
+            userId,
         });
         return;
     }