@aigne/cli 1.60.0-beta → 1.74.0-beta

package/dist/commands/hub.js

@@ -1,323 +0,0 @@
-import { AIGNE_HUB_URL } from "@aigne/aigne-hub";
-import chalk from "chalk";
-import Table from "cli-table3";
-import inquirer from "inquirer";
-import { isTest } from "../utils/aigne-hub/constants.js";
-import { connectToAIGNEHub } from "../utils/aigne-hub/credential.js";
-import getSecretStore from "../utils/aigne-hub/store/index.js";
-import { getUserInfo } from "../utils/aigne-hub-user.js";
-import { getUrlOrigin } from "../utils/get-url-origin.js";
-export const formatNumber = (balance) => {
-    const cleanNumber = String(balance).replace(/[^\d.-]/g, "");
-    const balanceNum = cleanNumber.split(".")[0];
-    if (!balanceNum) {
-        return "0";
-    }
-    return (balanceNum || "").trim().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
-};
-const formatNumberWithColor = (balance) => {
-    return chalk.yellow(formatNumber(balance));
-};
-function formatHubInfoName(name) {
-    return chalk.bold(`${name}:`.padEnd(10));
-}
-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} ✅`) : `${data.status}`}`);
-    console.log("");
-    console.log(chalk.bold("User:"));
-    console.log(`  ${formatHubInfoName("Name")} ${data.user.name}`);
-    console.log(`  ${formatHubInfoName("DID")} ${data.user.did}`);
-    console.log(`  ${formatHubInfoName("Email")} ${data.user.email}`);
-    console.log("");
-    if (data.enableCredit) {
-        console.log(chalk.bold("Credits:"));
-        console.log(`  ${formatHubInfoName("Total")} ${formatNumberWithColor(data.credits.total)}`);
-        console.log(`  ${formatHubInfoName("Used")} ${formatNumberWithColor(data.credits.used)}`);
-        console.log(`  ${formatHubInfoName("Available")} ${formatNumberWithColor(data.credits.available)}`);
-        console.log("");
-        console.log(chalk.bold("Links:"));
-        if (data.links.payment) {
-            console.log(`  ${formatHubInfoName("Payment")} ${data.links.payment}`);
-        }
-        if (data.links.profile) {
-            console.log(`  ${formatHubInfoName("Credits")} ${data.links.profile}`);
-        }
-    }
-}
-async function getHubs() {
-    try {
-        const secretStore = await getSecretStore();
-        const hosts = await secretStore.listHosts();
-        const statusList = [];
-        for (const host of hosts) {
-            statusList.push({
-                host: new URL(host.AIGNE_HUB_API_URL).host,
-                apiUrl: host.AIGNE_HUB_API_URL,
-                apiKey: host.AIGNE_HUB_API_KEY || "",
-            });
-        }
-        return statusList;
-    }
-    catch {
-        return [];
-    }
-}
-const getDefaultHub = async () => {
-    try {
-        const secretStore = await getSecretStore();
-        const defaultHost = await secretStore.getDefault();
-        return defaultHost?.AIGNE_HUB_API_URL || AIGNE_HUB_URL;
-    }
-    catch {
-        return AIGNE_HUB_URL;
-    }
-};
-async function formatHubsList(statusList) {
-    if (statusList?.length === 0) {
-        console.log(chalk.yellow("No AIGNE Hub connected."));
-        console.log("Use 'aigne hub connect' to connect to a hub.");
-        return;
-    }
-    const defaultHub = await getDefaultHub();
-    const table = new Table({
-        head: ["URL", "ACTIVE"],
-        colWidths: [70, 10],
-        style: {
-            head: ["cyan"],
-            border: ["grey"],
-        },
-    });
-    console.log(chalk.blue("Connected AIGNE Hubs:\n"));
-    for (const status of statusList) {
-        const isConnected = getUrlOrigin(status.apiUrl) === getUrlOrigin(defaultHub);
-        table.push([getUrlOrigin(status.apiUrl), isConnected ? "YES" : "NO"]);
-    }
-    console.log(table.toString());
-    console.log(chalk.blue("Use 'aigne hub use' to switch to a different hub."));
-}
-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({
-            command: "connect [url]",
-            describe: "Connect to an AIGNE Hub",
-            builder: (yargs) => yargs.positional("url", {
-                type: "string",
-                describe: "The URL of the AIGNE Hub to connect to",
-                default: null,
-            }),
-            handler: (args) => {
-                if (args.url) {
-                    saveAndConnect(args.url);
-                }
-                else {
-                    connectHub();
-                }
-            },
-        })
-            .command("use", "Switch to a different AIGNE Hub", useHub)
-            .command(["status", "st"], "Show details of a connected hub", showInfo)
-            .command(["remove", "rm"], "Remove a connected hub", removeHub)
-            .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 connected."));
-        return;
-    }
-    const { hubApiKey } = await inquirer.prompt({
-        type: "select",
-        name: "hubApiKey",
-        message: `Choose a hub to switch to:`,
-        choices: hubs.map((h) => ({
-            name: getUrlOrigin(h.apiUrl),
-            value: h.apiUrl,
-        })),
-    });
-    await setDefaultHub(hubApiKey);
-}
-async function removeHub() {
-    const hubs = await getHubs();
-    if (!hubs.length) {
-        console.log(chalk.yellow("No AIGNE Hub connected."));
-        return;
-    }
-    const { hubApiKey } = await inquirer.prompt({
-        type: "select",
-        name: "hubApiKey",
-        message: `Choose a hub to remove:`,
-        choices: hubs.map((h) => ({
-            name: getUrlOrigin(h.apiUrl),
-            value: h.apiUrl,
-        })),
-    });
-    await deleteHub(hubApiKey);
-}
-async function showInfo() {
-    const hubs = await getHubs();
-    if (!hubs.length) {
-        console.log(chalk.yellow("No AIGNE Hub connected."));
-        return;
-    }
-    const defaultHub = await getDefaultHub();
-    const defaultHubIndex = hubs.findIndex((h) => getUrlOrigin(h.apiUrl) === getUrlOrigin(defaultHub));
-    const { hubApiKey } = await inquirer.prompt({
-        type: "select",
-        name: "hubApiKey",
-        message: `Choose a hub to view info:`,
-        choices: hubs.map((h, index) => ({
-            name: `${getUrlOrigin(h.apiUrl)} ${defaultHubIndex === index ? "(connected)" : ""}`,
-            value: h.apiUrl,
-        })),
-    });
-    try {
-        await printHubDetails(hubApiKey);
-    }
-    catch (error) {
-        console.error(chalk.red("✗ Failed to print hub details:"), error.message);
-    }
-}
-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 secretStore = await getSecretStore();
-    const currentKey = await secretStore.getKey(url);
-    if (currentKey?.AIGNE_HUB_API_URL) {
-        await setDefaultHub(currentKey.AIGNE_HUB_API_URL);
-        console.log(chalk.green(`✓ Hub ${getUrlOrigin(currentKey.AIGNE_HUB_API_URL)} connected successfully.`));
-        return;
-    }
-    try {
-        if (isTest) {
-            await secretStore.setKey("https://hub.aigne.io/ai-kit", "test-key");
-            await secretStore.setDefault("https://hub.aigne.io/ai-kit");
-            console.log(chalk.green(`✓ Hub https://hub.aigne.io/ai-kit connected successfully.`));
-            return;
-        }
-        await connectToAIGNEHub(url);
-        console.log(chalk.green(`✓ Hub ${getUrlOrigin(url)} connected successfully.`));
-    }
-    catch (error) {
-        console.error(chalk.red("✗ Failed to connect:"), error.message);
-    }
-}
-async function setDefaultHub(url) {
-    try {
-        const secretStore = await getSecretStore();
-        const key = await secretStore.getKey(url);
-        if (!key) {
-            console.error(chalk.red("✗ Hub not found"));
-            return;
-        }
-        await secretStore.setDefault(key.AIGNE_HUB_API_URL);
-        console.log(chalk.green(`✓ Switched active hub to ${getUrlOrigin(url)}`));
-    }
-    catch {
-        console.error(chalk.red("✗ Failed to set default hub"));
-    }
-}
-async function deleteHub(url) {
-    try {
-        const secretStore = await getSecretStore();
-        const key = await secretStore.getKey(url);
-        if (!key) {
-            console.error(chalk.red("✗ Hub not found"));
-            return;
-        }
-        const defaultHub = await getDefaultHub();
-        await secretStore.deleteKey(url);
-        if (!defaultHub) {
-            return;
-        }
-        const isDefaultHub = getUrlOrigin(url) === getUrlOrigin(defaultHub);
-        if (isDefaultHub) {
-            await secretStore.deleteDefault();
-            const remainingHubs = await getHubs();
-            const nextHub = remainingHubs[0];
-            if (nextHub) {
-                await secretStore.setDefault(nextHub?.apiUrl);
-                console.log(chalk.green(`✓ Hub ${getUrlOrigin(url)} removed, switched to ${getUrlOrigin(nextHub?.apiUrl)}`));
-                return;
-            }
-        }
-        console.log(chalk.green(`✓ Hub ${getUrlOrigin(url)} removed`));
-    }
-    catch {
-        console.error(chalk.red("✗ Failed to delete hub"));
-    }
-}
-async function printHubDetails(url) {
-    const secretStore = await getSecretStore();
-    const key = await secretStore.getKey(url);
-    const defaultHub = await getDefaultHub();
-    const isDefault = getUrlOrigin(url) === getUrlOrigin(defaultHub);
-    const userInfo = await getUserInfo({
-        baseUrl: key?.AIGNE_HUB_API_URL || "",
-        apiKey: key?.AIGNE_HUB_API_KEY || "",
-    }).catch(() => null);
-    printHubStatus({
-        hub: getUrlOrigin(url),
-        status: isDefault ? "Connected" : "Not Used",
-        user: {
-            name: userInfo?.user.fullName || "",
-            did: userInfo?.user.did || "",
-            email: userInfo?.user.email || "",
-        },
-        credits: {
-            available: userInfo?.creditBalance?.balance || "0",
-            total: userInfo?.creditBalance?.total || "0",
-            used: String(parseFloat(userInfo?.creditBalance?.total || "0") -
-                parseFloat(userInfo?.creditBalance?.balance || "0")),
-        },
-        links: {
-            payment: userInfo?.paymentLink || "",
-            profile: userInfo?.profileLink || "",
-        },
-        enableCredit: userInfo?.enableCredit || false,
-    });
-}

package/dist/commands/observe.d.ts

@@ -1,7 +0,0 @@
-import type { CommandModule } from "yargs";
-interface ServeMCPOptions {
-    host: string;
-    port?: number;
-}
-export declare function createObservabilityCommand(): CommandModule<unknown, ServeMCPOptions>;
-export {};

package/dist/commands/observe.js

@@ -1,41 +0,0 @@
-import { tryOrThrow } from "@aigne/core/utils/type-utils.js";
-import { startObservabilityCLIServer } from "@aigne/observability-api/cli";
-import getObservabilityDbPath from "@aigne/observability-api/db-path";
-import chalk from "chalk";
-import detectPort from "detect-port";
-const DEFAULT_PORT = () => tryOrThrow(() => {
-    const { PORT } = process.env;
-    if (!PORT)
-        return 7890;
-    const port = Number.parseInt(PORT, 10);
-    if (!port || !Number.isInteger(port))
-        throw new Error(`Invalid PORT: ${PORT}`);
-    return port;
-}, (error) => new Error(`parse PORT error ${error.message}`));
-export function createObservabilityCommand() {
-    return {
-        command: "observe",
-        describe: "Start the observability server",
-        builder: (yargs) => {
-            return yargs
-                .option("host", {
-                type: "string",
-                describe: "Host to run the observability server on, use 0.0.0.0 to publicly expose the server",
-                default: "localhost",
-            })
-                .option("port", {
-                type: "number",
-                describe: "Port to run the observability server on",
-            });
-        },
-        handler: async (options) => {
-            const port = await detectPort(options.port || DEFAULT_PORT());
-            const dbUrl = getObservabilityDbPath();
-            process.once("SIGINT", async () => {
-                process.exit(0);
-            });
-            console.log("Observability database path:", chalk.greenBright(dbUrl));
-            await startObservabilityCLIServer({ port, dbUrl });
-        },
-    };
-}

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

@@ -1,6 +0,0 @@
-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

@@ -1,102 +0,0 @@
-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

@@ -1,9 +0,0 @@
-import type { CommandModule } from "yargs";
-export declare function createRunCommand({ aigneFilePath, }?: {
-    aigneFilePath?: string;
-}): CommandModule<unknown, {
-    version?: boolean;
-    path?: string;
-    entryAgent?: string;
-    interactive?: boolean;
-}>;

package/dist/commands/run.js

@@ -1,187 +0,0 @@
-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 { findAIGNEFile } from "@aigne/core/loader/index.js";
-import { logger } from "@aigne/core/utils/logger.js";
-import { flat, isNonNullable, pick } from "@aigne/core/utils/type-utils.js";
-import { Listr, PRESET_TIMER } from "@aigne/listr2";
-import { config } from "dotenv-flow";
-import yargs from "yargs";
-import { AIGNE_CLI_VERSION, CHAT_MODEL_OPTIONS } from "../constants.js";
-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 { withRunAgentCommonOptions } from "../utils/yargs.js";
-import { agentCommandModule, cliAgentCommandModule } from "./app/agent.js";
-let yargsInstance = null;
-export function createRunCommand({ aigneFilePath, } = {}) {
-    return {
-        // $0 must place after 'run' to make positional args work correctly
-        command: ["run [path] [entry-agent]", "$0"],
-        describe: "Run AIGNE for the specified path",
-        builder: async (yargs) => {
-            yargsInstance = yargs;
-            return yargs
-                .positional("path", {
-                type: "string",
-                describe: "Path to the agents directory or URL to an aigne project",
-                default: ".",
-            })
-                .positional("entry-agent", {
-                type: "string",
-                describe: "Name of the agent to run (defaults to the entry agent if not specified)",
-            })
-                .option("version", {
-                type: "boolean",
-                alias: "v",
-                describe: "Show version number",
-            })
-                .option("interactive", {
-                describe: "Run in interactive chat mode",
-                type: "boolean",
-                default: false,
-                alias: ["chat"],
-            })
-                .help(false)
-                .version(false)
-                .strict(false);
-        },
-        handler: async (options) => {
-            if (options.version) {
-                console.log(AIGNE_CLI_VERSION);
-                process.exit(0);
-                return;
-            }
-            if (!options.entryAgent && options.path) {
-                if (!(await exists(options.path)) && !isUrl(options.path)) {
-                    options.entryAgent = options.path;
-                    options.path = undefined;
-                }
-            }
-            const path = aigneFilePath || options.path || ".";
-            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
-            const opts = withRunAgentCommonOptions(yargs(process.argv).help(false).version(false).strict(false)).parseSync();
-            logger.level = opts.logLevel;
-            const { aigne } = await loadApplication(path, {
-                modelOptions: pick(opts, CHAT_MODEL_OPTIONS),
-                imageModelOptions: { model: opts.imageModel },
-            });
-            const subYargs = yargs().scriptName("").usage("aigne run <path> <agent> [...options]");
-            if (aigne.cli.chat) {
-                subYargs.command({
-                    ...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, interactive: options.interactive }));
-            }
-            for (const cliAgent of aigne.cli.agents ?? []) {
-                subYargs.command(cliAgentCommandModule({
-                    aigne,
-                    cliAgent,
-                }));
-            }
-            const argv = process.argv.slice(aigneFilePath ? 3 : 2);
-            if (argv[0] === "run")
-                argv.shift(); // remove 'run' command
-            // For compatibility with old `run` command like: `aigne run --path /xx/xx --entry-agent xx --xx`
-            if (argv[0] === "--path" || argv[0] === "--url")
-                argv.shift(); // remove --path flag
-            if (argv[0] === options.path)
-                argv.shift(); // remove path/url args
-            if (argv[0] === "--entry-agent")
-                argv.shift();
-            const firstAgent = aigne.agents[0]?.name;
-            if (!options.entryAgent && firstAgent && !argv.some((i) => ["-h", "--help"].includes(i))) {
-                argv.unshift(firstAgent);
-            }
-            await subYargs
-                .strict()
-                .demandCommand()
-                .alias("h", "help")
-                .alias("v", "version")
-                .fail((message, error, yargs) => {
-                // We catch all errors below, here just print the help message non-error case like demandCommand
-                if (!error) {
-                    yargs.showHelp();
-                    console.error(`\n${message}`);
-                    process.exit(1);
-                }
-            })
-                .parseAsync(argv);
-        },
-    };
-}
-async function loadApplication(path, options = {}) {
-    const { cacheDir, dir } = prepareDirs(path);
-    if (cacheDir) {
-        await new Listr([
-            {
-                title: "Download package",
-                task: () => downloadPackage(path, cacheDir),
-            },
-            {
-                title: "Extract package",
-                task: () => extractPackage(cacheDir, dir),
-            },
-        ], {
-            rendererOptions: {
-                collapseSubtasks: false,
-                showErrorMessage: false,
-                timer: PRESET_TIMER,
-            },
-        }).run();
-    }
-    // Load env files in the aigne directory
-    config({ path: dir, silent: true });
-    const aigne = await loadAIGNE({ ...options, path: dir });
-    return { aigne, path: dir };
-}
-async function downloadPackage(url, cacheDir) {
-    await rm(cacheDir, { recursive: true, force: true });
-    await mkdir(cacheDir, { recursive: true });
-    await downloadAndExtract(url, cacheDir);
-}
-async function extractPackage(cacheDir, dir) {
-    await mkdir(dir, { recursive: true });
-    if (await isV1Package(cacheDir)) {
-        await toAIGNEPackage(cacheDir, dir);
-    }
-    else {
-        await cp(cacheDir, dir, { recursive: true, force: true });
-    }
-}
-function prepareDirs(path) {
-    let dir;
-    let cacheDir;
-    if (!path.startsWith("http")) {
-        dir = isAbsolute(path) ? path : resolve(process.cwd(), path);
-    }
-    else {
-        dir = getLocalPackagePathFromUrl(path);
-        cacheDir = getLocalPackagePathFromUrl(path, { subdir: ".download" });
-    }
-    return { cacheDir, dir };
-}
-function getLocalPackagePathFromUrl(url, { subdir } = {}) {
-    const root = [homedir(), ".aigne", subdir].filter(isNonNullable);
-    const u = new URL(url);
-    return join(...root, u.hostname, u.pathname);
-}