@elizaos/cli 1.2.11-beta.6 → 1.2.11-beta.7

package/dist/{chunk-MHXS2LE3.js → chunk-BVMPDDVC.js}

@@ -2616,10 +2616,10 @@ async function createBranch(token, owner, repo, branch, baseBranch = "main") {
     return false;
   }
 }
-async function getFileContent(token, owner, repo, path21, branch = "main") {
+async function getFileContent(token, owner, repo, path22, branch = "main") {
   try {
     const response = await fetch(
-      `${GITHUB_API_URL}/repos/${owner}/${repo}/contents/${path21}?ref=${branch}`,
+      `${GITHUB_API_URL}/repos/${owner}/${repo}/contents/${path22}?ref=${branch}`,
       {
         headers: {
           Authorization: `token ${token}`,
@@ -2636,14 +2636,14 @@ async function getFileContent(token, owner, repo, path21, branch = "main") {
     return null;
   }
 }
-async function updateFile(token, owner, repo, path21, content, message, branch = "main") {
+async function updateFile(token, owner, repo, path22, content, message, branch = "main") {
   try {
-    const existingContent = await getFileContent(token, owner, repo, path21, branch);
+    const existingContent = await getFileContent(token, owner, repo, path22, branch);
     const method = "PUT";
     let sha;
     if (existingContent !== null) {
       const response2 = await fetch(
-        `${GITHUB_API_URL}/repos/${owner}/${repo}/contents/${path21}?ref=${branch}`,
+        `${GITHUB_API_URL}/repos/${owner}/${repo}/contents/${path22}?ref=${branch}`,
         {
           headers: {
             Authorization: `token ${token}`,
@@ -2656,7 +2656,7 @@ async function updateFile(token, owner, repo, path21, content, message, branch =
         sha = data.sha;
       }
     }
-    const fileUrl = `${GITHUB_API_URL}/repos/${owner}/${repo}/contents/${path21}`;
+    const fileUrl = `${GITHUB_API_URL}/repos/${owner}/${repo}/contents/${path22}`;
     logger10.info(`Updating file at: ${fileUrl}`);
     const requestBody = {
       message,
@@ -2682,7 +2682,7 @@ async function updateFile(token, owner, repo, path21, content, message, branch =
     logger10.error(`Failed to update file: ${response.status} ${response.statusText}`);
     logger10.error(`Response body: ${errorBody}`);
     if (response.status === 404) {
-      logger10.error(`Repository or path not found: ${owner}/${repo}/${path21}`);
+      logger10.error(`Repository or path not found: ${owner}/${repo}/${path22}`);
       const repoCheck = await fetch(`${GITHUB_API_URL}/repos/${owner}/${repo}`, {
         headers: {
           Authorization: `token ${token}`,
@@ -2761,7 +2761,7 @@ async function getGitHubCredentials() {
     }
     logger10.warn("Invalid GitHub token found in environment variables");
   }
-  const { getGitHubToken: getGitHubToken2 } = await import("./registry-FOWACLT2.js");
+  const { getGitHubToken: getGitHubToken2 } = await import("./registry-RLIFZR6O.js");
   const token = await getGitHubToken2() || void 0;
   if (token) {
     const isValid2 = await validateGitHubToken(token);
@@ -2848,11 +2848,11 @@ async function saveGitHubCredentials(username, token) {
   process.env.GITHUB_TOKEN = token;
   logger10.success("GitHub credentials saved");
 }
-async function ensureDirectory(token, repo, path21, branch) {
+async function ensureDirectory(token, repo, path22, branch) {
   try {
     try {
       const response = await fetch(
-        `${GITHUB_API_URL}/repos/${repo}/contents/${path21}?ref=${branch}`,
+        `${GITHUB_API_URL}/repos/${repo}/contents/${path22}?ref=${branch}`,
         {
           headers: {
             Authorization: `token ${token}`,
@@ -2861,27 +2861,27 @@ async function ensureDirectory(token, repo, path21, branch) {
         }
       );
       if (response.status === 200) {
-        logger10.info(`Directory ${path21} already exists`);
+        logger10.info(`Directory ${path22} already exists`);
         return true;
       }
     } catch (error) {
-      logger10.info(`Directory ${path21} doesn't exist, creating it`);
+      logger10.info(`Directory ${path22} doesn't exist, creating it`);
     }
-    const placeholderPath = `${path21}/.gitkeep`;
+    const placeholderPath = `${path22}/.gitkeep`;
     const result = await updateFile(
       token,
       repo,
       placeholderPath,
       "",
       // Empty content for placeholder
-      `Create directory: ${path21}`,
+      `Create directory: ${path22}`,
       branch
     );
     if (result) {
-      logger10.success(`Created directory: ${path21}`);
+      logger10.success(`Created directory: ${path22}`);
       return true;
     }
-    logger10.error(`Failed to create directory: ${path21}`);
+    logger10.error(`Failed to create directory: ${path22}`);
     return false;
   } catch (error) {
     logger10.error(
@@ -4177,21 +4177,171 @@ async function installPlugin(packageName, cwd, versionSpecifier, skipVerificatio
   return false;
 }
 
+// src/utils/local-cli-delegation.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync15 } from "fs";
+import path18 from "path";
+import { logger as logger19 } from "@elizaos/core";
+function isRunningFromLocalCli() {
+  try {
+    const currentScriptPath = process.argv[1];
+    if (!currentScriptPath) return false;
+    const absoluteScriptPath = path18.resolve(currentScriptPath);
+    const isInLocalCli = absoluteScriptPath.includes(path18.join("node_modules", "@elizaos", "cli"));
+    return isInLocalCli;
+  } catch (error) {
+    logger19.debug("Error checking if running from local CLI:", error);
+    return false;
+  }
+}
+function getLocalCliPath() {
+  const localCliPath = path18.join(
+    process.cwd(),
+    "node_modules",
+    "@elizaos",
+    "cli",
+    "dist",
+    "index.js"
+  );
+  return existsSync15(localCliPath) ? localCliPath : null;
+}
+function setupLocalEnvironment() {
+  const env = { ...process.env };
+  const localModulesPath = path18.join(process.cwd(), "node_modules");
+  if (existsSync15(localModulesPath)) {
+    if (env.NODE_PATH) {
+      env.NODE_PATH = `${localModulesPath}${path18.delimiter}${env.NODE_PATH}`;
+    } else {
+      env.NODE_PATH = localModulesPath;
+    }
+  }
+  const localBinPath = path18.join(process.cwd(), "node_modules", ".bin");
+  if (existsSync15(localBinPath)) {
+    if (env.PATH) {
+      env.PATH = `${localBinPath}${path18.delimiter}${env.PATH}`;
+    } else {
+      env.PATH = localBinPath;
+    }
+  }
+  env.FORCE_COLOR = "1";
+  return env;
+}
+async function delegateToLocalCli(localCliPath) {
+  return new Promise((resolve2, reject) => {
+    logger19.info("Using local @elizaos/cli installation");
+    const nodeExecutable = process.execPath;
+    const args = process.argv.slice(2);
+    const env = setupLocalEnvironment();
+    const childProcess = spawn(nodeExecutable, [localCliPath, ...args], {
+      stdio: "inherit",
+      // Inherit stdio to maintain interactive behavior
+      env,
+      cwd: process.cwd()
+    });
+    childProcess.on("exit", (code, signal) => {
+      if (code !== null) {
+        process.exit(code);
+      } else if (signal) {
+        const exitCode = signal === "SIGINT" ? 130 : signal === "SIGTERM" ? 143 : 1;
+        process.exit(exitCode);
+      }
+      resolve2();
+    });
+    childProcess.on("error", (error) => {
+      logger19.error(`Failed to start local CLI: ${error.message}`);
+      reject(error);
+    });
+    const forwardSignal = (signal) => {
+      process.on(signal, () => {
+        if (childProcess.killed === false) {
+          childProcess.kill(signal);
+        }
+      });
+    };
+    forwardSignal("SIGINT");
+    forwardSignal("SIGTERM");
+  });
+}
+function isTestEnvironment() {
+  const testIndicators = [
+    process.env.NODE_ENV === "test",
+    process.env.ELIZA_TEST_MODE === "true",
+    process.env.ELIZA_TEST_MODE === "1",
+    process.env.ELIZA_CLI_TEST_MODE === "true",
+    process.env.BUN_TEST === "true",
+    process.env.VITEST === "true",
+    process.env.JEST_WORKER_ID !== void 0,
+    process.argv.includes("--test"),
+    process.argv.includes("test"),
+    // Check if we're running under a test runner
+    process.argv[1]?.includes("test") === true,
+    // Check if parent process is a test runner
+    process.env.npm_lifecycle_event === "test"
+  ];
+  return testIndicators.some((indicator) => indicator === true);
+}
+async function tryDelegateToLocalCli() {
+  try {
+    if (isTestEnvironment()) {
+      logger19.debug("Running in test environment, skipping local CLI delegation");
+      return false;
+    }
+    if (isRunningFromLocalCli()) {
+      logger19.debug("Already running from local CLI, continuing execution");
+      return false;
+    }
+    const localCliPath = getLocalCliPath();
+    if (!localCliPath) {
+      logger19.debug("No local CLI found, using global installation");
+      return false;
+    }
+    await delegateToLocalCli(localCliPath);
+    return true;
+  } catch (error) {
+    logger19.error("Error during local CLI delegation:", error);
+    logger19.info("Falling back to global CLI installation");
+    return false;
+  }
+}
+function hasLocalCli() {
+  return getLocalCliPath() !== null;
+}
+function getCliContext() {
+  return {
+    isLocal: isRunningFromLocalCli(),
+    hasLocal: hasLocalCli(),
+    localPath: getLocalCliPath(),
+    currentPath: process.argv[1] || "unknown"
+  };
+}
+
 // src/utils/module-loader.ts
 import { createRequire } from "module";
 import { pathToFileURL } from "url";
-import { logger as logger19 } from "@elizaos/core";
-import path18 from "path";
-import { existsSync as existsSync15 } from "fs";
+import { logger as logger20 } from "@elizaos/core";
+import path19 from "path";
+import { existsSync as existsSync16 } from "fs";
 var ModuleLoader = class {
   require;
   cache = /* @__PURE__ */ new Map();
   projectPath;
-  constructor(projectPath = process.cwd()) {
-    this.projectPath = projectPath;
-    this.require = createRequire(pathToFileURL(projectPath + "/package.json").href);
+  constructor(projectPath) {
+    this.projectPath = projectPath || this.detectProjectPath();
+    this.require = createRequire(pathToFileURL(this.projectPath + "/package.json").href);
     this.setupEnvironment();
   }
+  /**
+   * Detect the appropriate project path, preferring monorepo root over current working directory
+   */
+  detectProjectPath() {
+    const monorepoRoot = UserEnvironment.getInstance().findMonorepoRoot(process.cwd());
+    if (monorepoRoot) {
+      logger20.debug(`Using monorepo root: ${monorepoRoot}`);
+      return monorepoRoot;
+    }
+    logger20.debug(`Using current working directory: ${process.cwd()}`);
+    return process.cwd();
+  }
   /**
    * Load a module from the project's node_modules directory.
    * Uses caching to ensure the same instance is returned for repeated calls.
@@ -4202,31 +4352,31 @@ var ModuleLoader = class {
    */
   async load(moduleName) {
     if (this.cache.has(moduleName)) {
-      logger19.debug(`Using cached module: ${moduleName}`);
+      logger20.debug(`Using cached module: ${moduleName}`);
       return this.cache.get(moduleName);
     }
     try {
-      const localModulePath = path18.join(this.projectPath, "node_modules", moduleName);
-      const isLocalModule = existsSync15(localModulePath);
+      const localModulePath = path19.join(this.projectPath, "node_modules", moduleName);
+      const isLocalModule = existsSync16(localModulePath);
       if (isLocalModule) {
-        logger19.info(`Using local ${moduleName} installation`);
+        logger20.info(`Using local ${moduleName} installation`);
       } else {
-        logger19.info(`Using global ${moduleName} installation`);
+        logger20.info(`Using global ${moduleName} installation`);
       }
       const modulePath = this.require.resolve(moduleName);
-      logger19.debug(`Loading ${moduleName} from: ${modulePath}`);
+      logger20.debug(`Loading ${moduleName} from: ${modulePath}`);
       if (isLocalModule && !modulePath.includes(this.projectPath)) {
-        logger19.warn(`Expected local module but resolved to global: ${modulePath}`);
+        logger20.warn(`Expected local module but resolved to global: ${modulePath}`);
       }
       const module = await import(pathToFileURL(modulePath).href);
       this.cache.set(moduleName, module);
-      logger19.success(
+      logger20.success(
         `Loaded ${moduleName} from ${isLocalModule ? "local" : "global"} installation`
       );
       return module;
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      logger19.error(`Failed to load module ${moduleName}: ${errorMessage}`);
+      logger20.error(`Failed to load module ${moduleName}: ${errorMessage}`);
       throw new Error(
         `Cannot find module '${moduleName}' in project at ${this.projectPath}.
 Please ensure it's installed by running:
@@ -4241,18 +4391,18 @@ Original error: ${errorMessage}`
    * This ensures the same local-first guarantees as server-manager.ts.
    */
   setupEnvironment() {
-    const localModulesPath = path18.join(this.projectPath, "node_modules");
-    if (existsSync15(localModulesPath)) {
+    const localModulesPath = path19.join(this.projectPath, "node_modules");
+    if (existsSync16(localModulesPath)) {
       if (process.env.NODE_PATH) {
-        process.env.NODE_PATH = `${localModulesPath}${path18.delimiter}${process.env.NODE_PATH}`;
+        process.env.NODE_PATH = `${localModulesPath}${path19.delimiter}${process.env.NODE_PATH}`;
       } else {
         process.env.NODE_PATH = localModulesPath;
       }
     }
-    const localBinPath = path18.join(this.projectPath, "node_modules", ".bin");
-    if (existsSync15(localBinPath)) {
+    const localBinPath = path19.join(this.projectPath, "node_modules", ".bin");
+    if (existsSync16(localBinPath)) {
       if (process.env.PATH) {
-        process.env.PATH = `${localBinPath}${path18.delimiter}${process.env.PATH}`;
+        process.env.PATH = `${localBinPath}${path19.delimiter}${process.env.PATH}`;
       } else {
         process.env.PATH = localBinPath;
       }
@@ -4308,22 +4458,22 @@ async function findNextAvailablePort(startPort) {
 }
 
 // src/utils/publisher.ts
-import { logger as logger20 } from "@elizaos/core";
+import { logger as logger21 } from "@elizaos/core";
 async function testPublishToNpm(cwd) {
   try {
     await bunExec("npm", ["whoami"]);
-    logger20.info("[\u2713] Logged in to npm");
-    logger20.info("Testing build...");
+    logger21.info("[\u2713] Logged in to npm");
+    logger21.info("Testing build...");
     await bunExec("npm", ["run", "build", "--dry-run"], { cwd });
-    logger20.info("[\u2713] Build test successful");
+    logger21.info("[\u2713] Build test successful");
     await bunExec("npm", ["access", "ls-packages"], { cwd });
-    logger20.info("[\u2713] Have publish permissions");
+    logger21.info("[\u2713] Have publish permissions");
     return true;
   } catch (error) {
-    logger20.error("Test failed:", error);
+    logger21.error("Test failed:", error);
     if (error instanceof Error) {
-      logger20.error(`Error message: ${error.message}`);
-      logger20.error(`Error stack: ${error.stack}`);
+      logger21.error(`Error message: ${error.message}`);
+      logger21.error(`Error stack: ${error.stack}`);
     }
     return false;
   }
@@ -4332,53 +4482,53 @@ async function testPublishToGitHub(packageJson, username) {
   try {
     const credentials = await getGitHubCredentials();
     if (!credentials) {
-      logger20.error("Failed to get GitHub credentials");
+      logger21.error("Failed to get GitHub credentials");
       return false;
     }
     const token = credentials.token;
-    logger20.info("[\u2713] GitHub credentials found");
+    logger21.info("[\u2713] GitHub credentials found");
     const response = await fetch("https://api.github.com/user", {
       headers: { Authorization: `token ${token}` }
     });
     if (!response.ok) {
-      logger20.error("Invalid GitHub token or insufficient permissions");
+      logger21.error("Invalid GitHub token or insufficient permissions");
       return false;
     }
-    logger20.info("[\u2713] GitHub token is valid");
+    logger21.info("[\u2713] GitHub token is valid");
     if (packageJson.packageType === "project") {
-      logger20.info("[\u2713] Project validation complete - GitHub token is valid");
+      logger21.info("[\u2713] Project validation complete - GitHub token is valid");
       return true;
     }
     const settings = await getRegistrySettings();
     const [registryOwner, registryRepo] = settings.defaultRegistry.split("/");
-    logger20.info(`Testing with registry: ${registryOwner}/${registryRepo}`);
+    logger21.info(`Testing with registry: ${registryOwner}/${registryRepo}`);
     const hasFork = await forkExists(token, registryRepo, username);
-    logger20.info(hasFork ? "[\u2713] Fork exists" : "[\u2713] Can create fork");
+    logger21.info(hasFork ? "[\u2713] Fork exists" : "[\u2713] Can create fork");
     if (!hasFork) {
-      logger20.info("Creating fork...");
+      logger21.info("Creating fork...");
       const forkCreated = await forkRepository(token, registryOwner, registryRepo);
       if (!forkCreated) {
-        logger20.error("Failed to create fork");
+        logger21.error("Failed to create fork");
         return false;
       }
-      logger20.info("[\u2713] Fork created");
+      logger21.info("[\u2713] Fork created");
       await new Promise((resolve2) => setTimeout(resolve2, 3e3));
     }
     const branchName = `test-${packageJson.name.replace(/^@[^/]+\//, "")}-${packageJson.version}`;
     const hasBranch = await branchExists(token, username, registryRepo, branchName);
-    logger20.info(hasBranch ? "[\u2713] Test branch exists" : "[\u2713] Can create branch");
+    logger21.info(hasBranch ? "[\u2713] Test branch exists" : "[\u2713] Can create branch");
     if (!hasBranch) {
-      logger20.info("Creating branch...");
+      logger21.info("Creating branch...");
       const branchCreated = await createBranch(token, username, registryRepo, branchName, "main");
       if (!branchCreated) {
-        logger20.error("Failed to create branch");
+        logger21.error("Failed to create branch");
         return false;
       }
-      logger20.info("[\u2713] Branch created");
+      logger21.info("[\u2713] Branch created");
     }
     const simpleName = packageJson.name.replace(/^@[^/]+\//, "").replace(/[^a-zA-Z0-9-]/g, "-");
     const testPath = `test-files/${simpleName}-test.json`;
-    logger20.info(`Attempting to create test file: ${testPath} in branch: ${branchName}`);
+    logger21.info(`Attempting to create test file: ${testPath} in branch: ${branchName}`);
     const dirCreated = await ensureDirectory(
       token,
       `${username}/${registryRepo}`,
@@ -4386,7 +4536,7 @@ async function testPublishToGitHub(packageJson, username) {
       branchName
     );
     if (!dirCreated) {
-      logger20.warn("Failed to create test directory, but continuing with file creation");
+      logger21.warn("Failed to create test directory, but continuing with file creation");
     }
     const canUpdate = await updateFile(
       token,
@@ -4399,53 +4549,53 @@ async function testPublishToGitHub(packageJson, username) {
       // Use the test branch instead of main
     );
     if (!canUpdate) {
-      logger20.error("Cannot update files in repository");
+      logger21.error("Cannot update files in repository");
       return false;
     }
-    logger20.info("[\u2713] Can create and update files");
+    logger21.info("[\u2713] Can create and update files");
     return true;
   } catch (error) {
-    logger20.error("Test failed:", error);
+    logger21.error("Test failed:", error);
     return false;
   }
 }
 async function publishToNpm(cwd) {
   try {
     await bunExec("npm", ["whoami"]);
-    logger20.info("Building package...");
+    logger21.info("Building package...");
     await bunExecInherit("npm", ["run", "build"], { cwd });
-    logger20.info("Publishing to npm...");
+    logger21.info("Publishing to npm...");
     await bunExecInherit("npm", ["publish"], { cwd });
     return true;
   } catch (error) {
-    logger20.error("Failed to publish to npm:", error);
+    logger21.error("Failed to publish to npm:", error);
     return false;
   }
 }
 async function publishToGitHub(cwd, packageJson, username, skipRegistry = false, isTest = false) {
   const credentials = await getGitHubCredentials();
   if (!credentials) {
-    logger20.error("Failed to get GitHub credentials");
+    logger21.error("Failed to get GitHub credentials");
     return false;
   }
   const token = credentials.token;
   if (!packageJson.packageType) {
-    logger20.error(
+    logger21.error(
       'Package type is required. Set "packageType" to either "plugin" or "project" in package.json'
     );
     return false;
   }
   if (packageJson.packageType !== "plugin" && packageJson.packageType !== "project") {
-    logger20.error(
+    logger21.error(
       `Invalid package type: ${packageJson.packageType}. Must be either "plugin" or "project"`
     );
     return false;
   }
   if (isTest) {
-    logger20.info("Running in test mode - no actual changes will be made");
+    logger21.info("Running in test mode - no actual changes will be made");
   }
   if (skipRegistry) {
-    logger20.info("Registry updates will be skipped as requested with --skip-registry flag");
+    logger21.info("Registry updates will be skipped as requested with --skip-registry flag");
   }
   if (!isTest) {
     const repoName = packageJson.name.replace(/^@[^/]+\//, "");
@@ -4458,24 +4608,24 @@ async function publishToGitHub(cwd, packageJson, username, skipRegistry = false,
     } else {
       topic = "elizaos-plugins";
     }
-    logger20.info(`Checking/creating GitHub repository: ${username}/${repoName}`);
+    logger21.info(`Checking/creating GitHub repository: ${username}/${repoName}`);
     const repoResult = await createGitHubRepository(token, repoName, description, false, [topic]);
     if (!repoResult.success) {
-      logger20.error(`Failed to create GitHub repository: ${repoResult.message}`);
+      logger21.error(`Failed to create GitHub repository: ${repoResult.message}`);
       return false;
     }
-    logger20.info(`Using repository: ${repoResult.repoUrl}`);
+    logger21.info(`Using repository: ${repoResult.repoUrl}`);
     const repoUrl = `https://${token}@github.com/${username}/${repoName}.git`;
-    logger20.info("Pushing code to GitHub...");
+    logger21.info("Pushing code to GitHub...");
     const pushSuccess = await pushToGitHub(cwd, repoUrl);
     if (!pushSuccess) {
-      logger20.error("Failed to push code to GitHub repository.");
+      logger21.error("Failed to push code to GitHub repository.");
       return false;
     }
-    logger20.success("Successfully pushed code to GitHub repository");
+    logger21.success("Successfully pushed code to GitHub repository");
     if (packageJson.packageType === "project" || skipRegistry) {
       const reason = packageJson.packageType === "project" ? "Projects do not need registry updates" : "Registry updates skipped as requested with --skip-registry flag";
-      logger20.info(`${packageJson.name} published to GitHub successfully. ${reason}`);
+      logger21.info(`${packageJson.name} published to GitHub successfully. ${reason}`);
       return {
         success: true,
         prUrl: repoResult.repoUrl
@@ -4484,7 +4634,7 @@ async function publishToGitHub(cwd, packageJson, username, skipRegistry = false,
   }
   if (packageJson.packageType === "project" || skipRegistry) {
     if (isTest) {
-      logger20.info("Test successful - project would be published to GitHub only");
+      logger21.info("Test successful - project would be published to GitHub only");
     }
     return true;
   }
@@ -4493,33 +4643,33 @@ async function publishToGitHub(cwd, packageJson, username, skipRegistry = false,
   const hasFork = await forkExists(token, registryRepo, username);
   let forkFullName;
   if (!hasFork && !isTest) {
-    logger20.info(`Creating fork of ${settings.defaultRegistry}...`);
+    logger21.info(`Creating fork of ${settings.defaultRegistry}...`);
     const fork = await forkRepository(token, registryOwner, registryRepo);
     if (!fork) {
-      logger20.error("Failed to fork registry repository.");
+      logger21.error("Failed to fork registry repository.");
       return false;
     }
     forkFullName = fork;
     await new Promise((resolve2) => setTimeout(resolve2, 2e3));
   } else {
     forkFullName = `${username}/${registryRepo}`;
-    logger20.info(`Using existing fork: ${forkFullName}`);
+    logger21.info(`Using existing fork: ${forkFullName}`);
   }
   const entityType = packageJson.packageType;
   const packageNameWithoutScope = packageJson.name.replace(/^@[^/]+\//, "");
   let branchName;
   if (entityType === "plugin" && packageNameWithoutScope.startsWith("plugin-")) {
     branchName = `${packageNameWithoutScope}-${packageJson.version}`;
-    logger20.info(`Using package name directly to avoid duplicate plugin prefix: ${branchName}`);
+    logger21.info(`Using package name directly to avoid duplicate plugin prefix: ${branchName}`);
   } else {
     branchName = `${entityType}-${packageNameWithoutScope}-${packageJson.version}`;
   }
   const hasBranch = await branchExists(token, username, registryRepo, branchName);
   if (!hasBranch && !isTest) {
-    logger20.info(`Creating branch ${branchName}...`);
+    logger21.info(`Creating branch ${branchName}...`);
     const created = await createBranch(token, username, registryRepo, branchName);
     if (!created) {
-      logger20.error("Failed to create branch.");
+      logger21.error("Failed to create branch.");
       return false;
     }
   }
@@ -4532,10 +4682,10 @@ async function publishToGitHub(cwd, packageJson, username, skipRegistry = false,
         const githubRepo = `github:${username}/${packageName}`;
         const index = JSON.parse(indexContent);
         if (index[registryPackageName]) {
-          logger20.warn(`Package ${registryPackageName} already exists in registry`);
+          logger21.warn(`Package ${registryPackageName} already exists in registry`);
           return false;
         }
-        logger20.info(`Adding registry entry: ${registryPackageName} -> ${githubRepo}`);
+        logger21.info(`Adding registry entry: ${registryPackageName} -> ${githubRepo}`);
         const lines = indexContent.split("\n");
         const newEntry = `    "${registryPackageName}": "${githubRepo}",`;
         let insertIndex = -1;
@@ -4564,7 +4714,7 @@ async function publishToGitHub(cwd, packageJson, username, skipRegistry = false,
           }
         }
         if (insertIndex === -1) {
-          logger20.error("Could not find insertion point in index.json");
+          logger21.error("Could not find insertion point in index.json");
           return false;
         }
         lines.splice(insertIndex, 0, newEntry);
@@ -4579,15 +4729,15 @@ async function publishToGitHub(cwd, packageJson, username, skipRegistry = false,
           branchName
         );
         if (!indexUpdated) {
-          logger20.error("Failed to update registry index.");
+          logger21.error("Failed to update registry index.");
           return false;
         }
       } else {
-        logger20.error("Could not fetch index.json from registry");
+        logger21.error("Could not fetch index.json from registry");
         return false;
       }
     } catch (error) {
-      logger20.error(
+      logger21.error(
         `Failed to update index.json: ${error instanceof Error ? error.message : String(error)}`
       );
       return false;
@@ -4609,20 +4759,20 @@ Submitted by: @${username}`,
       "main"
     );
     if (!prUrl) {
-      logger20.error("Failed to create pull request.");
+      logger21.error("Failed to create pull request.");
       return false;
     }
-    logger20.success(`Pull request created: ${prUrl}`);
+    logger21.success(`Pull request created: ${prUrl}`);
     return {
       success: true,
       prUrl
     };
   } else {
-    logger20.info("Test successful - all checks passed");
-    logger20.info("Would create:");
-    logger20.info(`- Branch: ${branchName}`);
-    logger20.info(`- Registry entry: ${registryPackageName} -> github:${username}/${packageName}`);
-    logger20.info(`- Pull request: Add ${registryPackageName} to registry`);
+    logger21.info("Test successful - all checks passed");
+    logger21.info("Would create:");
+    logger21.info(`- Branch: ${branchName}`);
+    logger21.info(`- Registry entry: ${registryPackageName} -> github:${username}/${packageName}`);
+    logger21.info(`- Pull request: Add ${registryPackageName} to registry`);
   }
   return true;
 }
@@ -4637,17 +4787,17 @@ async function resolveImport(importPath, config) {
 
 // src/utils/test-runner.ts
 import {
-  logger as logger21
+  logger as logger22
 } from "@elizaos/core";
 import * as fs9 from "fs";
-import * as path19 from "path";
+import * as path20 from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 var safeLogger = {
-  debug: logger21?.debug || console.log,
-  info: logger21?.info || console.log,
-  warn: logger21?.warn || console.warn,
-  error: logger21?.error || console.error,
-  success: logger21?.success || console.log
+  debug: logger22?.debug || console.log,
+  info: logger22?.info || console.log,
+  warn: logger22?.warn || console.warn,
+  error: logger22?.error || console.error,
+  success: logger22?.success || console.log
 };
 var TestRunner = class {
   runtime;
@@ -4824,14 +4974,14 @@ export const myPlugin = {
       return;
     }
     try {
-      const e2eDir = path19.join(process.cwd(), "e2e");
+      const e2eDir = path20.join(process.cwd(), "e2e");
       if (!fs9.existsSync(e2eDir)) {
         safeLogger.debug("No e2e directory found, skipping e2e tests");
         return;
       }
       safeLogger.info("\nRunning e2e tests...");
       const walk = (dir) => fs9.readdirSync(dir, { withFileTypes: true }).flatMap(
-        (entry) => entry.isDirectory() ? walk(path19.join(dir, entry.name)) : entry.name.match(/\.test\.(t|j)sx?$/) ? [path19.join(dir, entry.name)] : []
+        (entry) => entry.isDirectory() ? walk(path20.join(dir, entry.name)) : entry.name.match(/\.test\.(t|j)sx?$/) ? [path20.join(dir, entry.name)] : []
       );
       const testFiles = walk(e2eDir);
       if (testFiles.length === 0) {
@@ -4839,16 +4989,16 @@ export const myPlugin = {
         return;
       }
       safeLogger.info(`Found ${testFiles.length} e2e test files`);
-      const distE2eDir = path19.join(process.cwd(), "dist", "e2e");
+      const distE2eDir = path20.join(process.cwd(), "dist", "e2e");
       const hasDistE2e = fs9.existsSync(distE2eDir);
       for (const testFile of testFiles) {
         try {
-          const fileName = path19.basename(testFile);
-          const fileNameWithoutExt = path19.basename(testFile, ".test.ts");
+          const fileName = path20.basename(testFile);
+          const fileNameWithoutExt = path20.basename(testFile, ".test.ts");
           safeLogger.info(`Loading test file: ${fileName}`);
           let moduleImportPath = testFile;
           if (hasDistE2e) {
-            const distFile = path19.join(distE2eDir, `${fileNameWithoutExt}.test.js`);
+            const distFile = path20.join(distE2eDir, `${fileNameWithoutExt}.test.js`);
             if (fs9.existsSync(distFile)) {
               moduleImportPath = distFile;
               safeLogger.debug(`Using compiled version from ${distFile}`);
@@ -4921,11 +5071,11 @@ Test Summary: ${this.stats.passed} passed, ${this.stats.failed} failed, ${this.s
 };
 
 // src/utils/registry/index.ts
-import { logger as logger22 } from "@elizaos/core";
+import { logger as logger23 } from "@elizaos/core";
 import dotenv3 from "dotenv";
 import { HttpsProxyAgent } from "https-proxy-agent";
-import { existsSync as existsSync17, promises as fs10 } from "fs";
-import path20 from "path";
+import { existsSync as existsSync18, promises as fs10 } from "fs";
+import path21 from "path";
 
 // src/utils/registry/constants.ts
 var REGISTRY_ORG = "elizaos-plugins";
@@ -4936,10 +5086,10 @@ var REGISTRY_GITHUB_URL = `https://github.com/${REGISTRY_REPO}`;
 var RAW_REGISTRY_URL = REGISTRY_URL;
 
 // src/utils/registry/index.ts
-var ELIZA_DIR = path20.join(process.cwd(), ".eliza");
-var REGISTRY_SETTINGS_FILE = path20.join(ELIZA_DIR, "registrysettings.json");
-var ENV_FILE = resolveEnvFile() || path20.join(ELIZA_DIR, ".env");
-var REGISTRY_CACHE_FILE = path20.join(ELIZA_DIR, "registry-cache.json");
+var ELIZA_DIR = path21.join(process.cwd(), ".eliza");
+var REGISTRY_SETTINGS_FILE = path21.join(ELIZA_DIR, "registrysettings.json");
+var ENV_FILE = resolveEnvFile() || path21.join(ELIZA_DIR, ".env");
+var REGISTRY_CACHE_FILE = path21.join(ELIZA_DIR, "registry-cache.json");
 var REQUIRED_ENV_VARS = ["GITHUB_TOKEN"];
 var REQUIRED_SETTINGS = ["defaultRegistry"];
 async function ensureElizaDir2() {
@@ -4987,19 +5137,19 @@ async function setEnvVar(key, value) {
 async function getGitHubToken() {
   try {
     const envPath = resolveEnvFile();
-    if (envPath && existsSync17(envPath)) {
+    if (envPath && existsSync18(envPath)) {
       const envContent = await fs10.readFile(envPath, "utf-8");
       const env = dotenv3.parse(envContent);
       return env.GITHUB_TOKEN;
     }
-    const globalEnvPath = path20.join(ELIZA_DIR, ".env");
-    if (existsSync17(globalEnvPath) && globalEnvPath !== envPath) {
+    const globalEnvPath = path21.join(ELIZA_DIR, ".env");
+    if (existsSync18(globalEnvPath) && globalEnvPath !== envPath) {
       const envContent = await fs10.readFile(globalEnvPath, "utf-8");
       const env = dotenv3.parse(envContent);
       return env.GITHUB_TOKEN;
     }
   } catch (error) {
-    logger22.debug(
+    logger23.debug(
       `Error reading GitHub token: ${error instanceof Error ? error.message : String(error)}`
     );
   }
@@ -5010,7 +5160,7 @@ async function setGitHubToken(token) {
   try {
     let envContent = "";
     try {
-      if (existsSync17(ENV_FILE)) {
+      if (existsSync18(ENV_FILE)) {
         envContent = await fs10.readFile(ENV_FILE, "utf-8");
       }
     } catch (error) {
@@ -5025,9 +5175,9 @@ async function setGitHubToken(token) {
     }
     await fs10.writeFile(ENV_FILE, newContent);
     process.env.GITHUB_TOKEN = token;
-    logger22.debug("GitHub token saved successfully");
+    logger23.debug("GitHub token saved successfully");
   } catch (error) {
-    logger22.error(
+    logger23.error(
       `Failed to save GitHub token: ${error instanceof Error ? error.message : String(error)}`
     );
   }
@@ -5070,16 +5220,16 @@ async function saveRegistryCache(registry) {
   try {
     await ensureElizaDir2();
     await fs10.writeFile(REGISTRY_CACHE_FILE, JSON.stringify(registry, null, 2));
-    logger22.debug("Registry cache saved successfully");
+    logger23.debug("Registry cache saved successfully");
   } catch (error) {
-    logger22.debug(
+    logger23.debug(
       `Failed to save registry cache: ${error instanceof Error ? error.message : String(error)}`
     );
   }
 }
 async function getLocalRegistryIndex() {
   try {
-    logger22.debug("Fetching registry from public GitHub URL");
+    logger23.debug("Fetching registry from public GitHub URL");
     const response = await fetch(RAW_REGISTRY_URL);
     if (response.ok) {
       const rawData = await response.json();
@@ -5091,24 +5241,24 @@ async function getLocalRegistryIndex() {
           }
         }
         await saveRegistryCache(result);
-        logger22.debug("Successfully fetched registry from public GitHub URL");
+        logger23.debug("Successfully fetched registry from public GitHub URL");
         return result;
       }
     }
   } catch (error) {
-    logger22.debug(
+    logger23.debug(
       `Failed to fetch registry from public URL: ${error instanceof Error ? error.message : String(error)}`
     );
   }
   try {
-    if (existsSync17(REGISTRY_CACHE_FILE)) {
+    if (existsSync18(REGISTRY_CACHE_FILE)) {
       const cacheContent = await fs10.readFile(REGISTRY_CACHE_FILE, "utf-8");
       const cachedRegistry = JSON.parse(cacheContent);
-      logger22.debug("Using cached registry index");
+      logger23.debug("Using cached registry index");
       return cachedRegistry;
     }
   } catch (error) {
-    logger22.debug(
+    logger23.debug(
       `Failed to read registry cache: ${error instanceof Error ? error.message : String(error)}`
     );
   }
@@ -5125,7 +5275,7 @@ async function getLocalRegistryIndex() {
       }
       return { ...DEFAULT_REGISTRY, ...localRegistry };
     } catch (error) {
-      logger22.debug(
+      logger23.debug(
         `Failed to discover local plugins: ${error instanceof Error ? error.message : String(error)}`
       );
     }
@@ -5136,7 +5286,7 @@ async function getRegistryIndex() {
   const settings = await getRegistrySettings();
   const credentials = await getGitHubCredentials();
   if (!credentials) {
-    logger22.error("GitHub credentials not found. Please run login first.");
+    logger23.error("GitHub credentials not found. Please run login first.");
     process.exit(1);
   }
   const [owner, repo] = settings.defaultRegistry.split("/");
@@ -5193,7 +5343,7 @@ async function getPluginRepository(pluginName) {
     const registry = await getLocalRegistryIndex();
     for (const name of possibleNames) {
       if (registry[name]) {
-        logger22.debug(`Found plugin in registry as: ${name}`);
+        logger23.debug(`Found plugin in registry as: ${name}`);
         return registry[name];
       }
     }
@@ -5206,7 +5356,7 @@ async function getPluginRepository(pluginName) {
     }
     return null;
   } catch (error) {
-    logger22.debug(
+    logger23.debug(
       `Error getting plugin repository: ${error instanceof Error ? error.message : String(error)}`
     );
     return null;
@@ -5217,7 +5367,7 @@ async function repoHasBranch(repoUrl, branchName) {
     const { stdout } = await bunExecSimple("git", ["ls-remote", "--heads", repoUrl, branchName]);
     return stdout.includes(branchName);
   } catch (error) {
-    logger22.warn(
+    logger23.warn(
       `Failed to check for branch ${branchName} in ${repoUrl}: ${error instanceof Error ? error.message : String(error)}`
     );
     return false;
@@ -5240,7 +5390,7 @@ async function getPluginMetadata(pluginName) {
   const settings = await getRegistrySettings();
   const credentials = await getGitHubCredentials();
   if (!credentials) {
-    logger22.error("GitHub credentials not found. Please run login first.");
+    logger23.error("GitHub credentials not found. Please run login first.");
     process.exit(1);
   }
   const [owner, repo] = settings.defaultRegistry.split("/");
@@ -5269,7 +5419,7 @@ async function getPluginMetadata(pluginName) {
     }
     return metadata;
   } catch (error) {
-    logger22.error("Failed to fetch plugin metadata:", error);
+    logger23.error("Failed to fetch plugin metadata:", error);
     return null;
   }
 }
@@ -5283,7 +5433,7 @@ async function getPluginVersion(pluginName, version) {
       return packageDetails.latestVersion;
     }
   } catch (error) {
-    logger22.debug(
+    logger23.debug(
       `Error getting package details: ${error instanceof Error ? error.message : String(error)}`
     );
   }
@@ -5317,11 +5467,11 @@ async function getPackageDetails(packageName) {
     try {
       return JSON.parse(text4);
     } catch {
-      logger22.warn(`Invalid JSON response received from registry for package ${packageName}:`, text4);
+      logger23.warn(`Invalid JSON response received from registry for package ${packageName}:`, text4);
       return null;
     }
   } catch (error) {
-    logger22.warn(
+    logger23.warn(
       `Failed to fetch package details from registry: ${error instanceof Error ? error.message : String(error)}`
     );
     return null;
@@ -5338,14 +5488,14 @@ async function getBestPluginVersion(packageName, runtimeVersion) {
   const [runtimeMajor, runtimeMinor] = runtimeVersion.split(".").map(Number);
   const [packageMajor, packageMinor] = packageDetails.runtimeVersion.split(".").map(Number);
   if (runtimeMajor !== packageMajor) {
-    logger22.warn(
+    logger23.warn(
       `Plugin ${packageName} was built for runtime v${packageDetails.runtimeVersion}, but you're using v${runtimeVersion}`
     );
-    logger22.warn("This may cause compatibility issues.");
+    logger23.warn("This may cause compatibility issues.");
     return packageDetails.latestVersion;
   }
   if (runtimeMinor !== packageMinor) {
-    logger22.warn(
+    logger23.warn(
       `Plugin ${packageName} was built for runtime v${packageDetails.runtimeVersion}, you're using v${runtimeVersion}`
     );
   }
@@ -5407,7 +5557,7 @@ async function initializeDataDir() {
 async function validateDataDir() {
   const status = await checkDataDir();
   if (!status.exists) {
-    logger22.warn("ElizaOS data directory not found. Initializing...");
+    logger23.warn("ElizaOS data directory not found. Initializing...");
     await initializeDataDir();
     return false;
   }
@@ -5417,22 +5567,22 @@ async function validateDataDir() {
     const envContent = await fs10.readFile(envPath, "utf-8");
     const parsedEnv = dotenv3.parse(envContent);
     if (!parsedEnv.GITHUB_TOKEN) {
-      logger22.warn("GitHub token not found in environment");
+      logger23.warn("GitHub token not found in environment");
       isValid = false;
     }
   } else {
-    logger22.warn(".env file not found");
+    logger23.warn(".env file not found");
     isValid = false;
   }
   if (!status.env.hasAllKeys) {
-    logger22.warn(`Missing environment variables: ${status.env.missingKeys.join(", ")}`);
+    logger23.warn(`Missing environment variables: ${status.env.missingKeys.join(", ")}`);
     isValid = false;
   }
   if (!status.settings.exists) {
-    logger22.warn("Registry settings file not found");
+    logger23.warn("Registry settings file not found");
     isValid = false;
   } else if (!status.settings.hasAllKeys) {
-    logger22.warn(`Missing settings: ${status.settings.missingKeys.join(", ")}`);
+    logger23.warn(`Missing settings: ${status.settings.missingKeys.join(", ")}`);
     isValid = false;
   }
   return isValid;
@@ -5570,6 +5720,9 @@ export {
   executeInstallationWithFallback,
   fetchPluginRegistry,
   installPlugin,
+  tryDelegateToLocalCli,
+  hasLocalCli,
+  getCliContext,
   ModuleLoader,
   getModuleLoader,
   loadModule,