@elizaos/app-core 2.0.0-alpha.85 → 2.0.0-beta.2

package/test-support/test-helpers.js

@@ -0,0 +1,410 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { EventEmitter } from "node:events";
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+/**
+ * Test helper utilities shared across unit tests.
+ */
+const OPTIONAL_IMPORT_ERROR_MARKERS = [
+    "Cannot find module",
+    "Cannot find package",
+    "ERR_MODULE_NOT_FOUND",
+    "MODULE_NOT_FOUND",
+    "Dynamic require of",
+    "native addon module",
+    "Failed to resolve entry",
+    "tfjs_binding",
+    "NAPI_MODULE_NOT_FOUND",
+    "spec not found",
+];
+/** Snapshot and restore the configured environment variables around a test. */
+export function createEnvSandbox(keys) {
+    const backup = {};
+    function clear() {
+        for (const key of keys) {
+            backup[key] = process.env[key];
+            delete process.env[key];
+        }
+    }
+    function restore() {
+        for (const key of keys) {
+            if (backup[key] === undefined) {
+                delete process.env[key];
+            }
+            else {
+                process.env[key] = backup[key];
+            }
+        }
+    }
+    return { clear, restore };
+}
+/** Loose plugin-shape predicate used in dynamic test imports across suites. */
+export function looksLikePlugin(value) {
+    return (value != null &&
+        typeof value === "object" &&
+        typeof value.name === "string");
+}
+/** Extract a plugin-like object from a dynamic module export shape. */
+export function extractPlugin(mod) {
+    if (looksLikePlugin(mod.default))
+        return mod.default;
+    if (looksLikePlugin(mod.plugin))
+        return mod.plugin;
+    if (looksLikePlugin(mod))
+        return mod;
+    for (const key of Object.keys(mod)) {
+        if (key === "default" || key === "plugin")
+            continue;
+        if (looksLikePlugin(mod[key]))
+            return mod[key];
+    }
+    return null;
+}
+/** Check whether a package name can be resolved for dynamic import. */
+export function isPackageImportResolvable(packageName) {
+    const require = createRequire(import.meta.url);
+    try {
+        require.resolve(packageName);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Check whether a dependency specifier should be treated as a workspace-local version. */
+export function isWorkspaceDependency(version) {
+    return (typeof version === "string" &&
+        (version.startsWith(".") || version.startsWith("workspace:")));
+}
+const DISCORD_PLUGIN_PACKAGE_NAME = "@elizaos/plugin-discord";
+const DISCORD_PLUGIN_LOCAL_ENTRY_CANDIDATES = [
+    "../plugins/plugin-discord/dist/index",
+];
+/**
+ * Resolve the Discord plugin import specifier.
+ * Prefers package resolution, then falls back to local plugin checkout paths.
+ */
+export function resolveDiscordPluginImportSpecifier() {
+    if (isPackageImportResolvable(DISCORD_PLUGIN_PACKAGE_NAME)) {
+        return DISCORD_PLUGIN_PACKAGE_NAME;
+    }
+    const helperDir = path.dirname(fileURLToPath(import.meta.url));
+    const packageRoot = path.resolve(helperDir, "..", "..");
+    for (const relativeEntryPath of DISCORD_PLUGIN_LOCAL_ENTRY_CANDIDATES) {
+        const absoluteEntryPath = path.resolve(packageRoot, relativeEntryPath);
+        if (existsSync(absoluteEntryPath)) {
+            return pathToFileURL(absoluteEntryPath).href;
+        }
+    }
+    return null;
+}
+const TELEGRAM_PLUGIN_PACKAGE_NAME = "@elizaos/plugin-telegram";
+const TELEGRAM_PLUGIN_LOCAL_ENTRY_CANDIDATES = [
+    "../plugins/plugin-telegram/dist/index",
+];
+/**
+ * Resolve the Telegram plugin import specifier.
+ * Prefers package resolution, then falls back to node_modules ESM entry
+ * (the telegram plugin is ESM-only so CJS require.resolve fails), then
+ * falls back to local plugin checkout paths.
+ */
+export function resolveTelegramPluginImportSpecifier() {
+    if (isPackageImportResolvable(TELEGRAM_PLUGIN_PACKAGE_NAME)) {
+        return TELEGRAM_PLUGIN_PACKAGE_NAME;
+    }
+    const helperDir = path.dirname(fileURLToPath(import.meta.url));
+    const packageRoot = path.resolve(helperDir, "..", "..");
+    // ESM-only: try direct node_modules entry
+    const nodeModulesEntry = path.resolve(packageRoot, "node_modules", "@elizaos", "plugin-telegram", "dist", "index.js");
+    if (existsSync(nodeModulesEntry)) {
+        return pathToFileURL(nodeModulesEntry).href;
+    }
+    for (const relativeEntryPath of TELEGRAM_PLUGIN_LOCAL_ENTRY_CANDIDATES) {
+        const absoluteEntryPath = path.resolve(packageRoot, relativeEntryPath);
+        if (existsSync(absoluteEntryPath)) {
+            return pathToFileURL(absoluteEntryPath).href;
+        }
+    }
+    return null;
+}
+const LENS_PLUGIN_PACKAGE_NAME = "@elizaos/plugin-lens";
+const LENS_PLUGIN_FALLBACK_PACKAGE = "@elizaos-plugins/client-lens";
+const LENS_PLUGIN_LOCAL_ENTRY_CANDIDATES = [
+    "../plugins/plugin-lens/dist/index",
+    "../../client-lens/dist/index",
+    "../../client-lens/src/index",
+];
+/**
+ * Resolve the Lens plugin import specifier.
+ * Prefers package resolution, then falls back to local plugin checkout paths.
+ * Uses both CJS require.resolve and a direct node_modules check for ESM-only packages.
+ */
+export function resolveLensPluginImportSpecifier() {
+    if (isPackageImportResolvable(LENS_PLUGIN_PACKAGE_NAME)) {
+        return LENS_PLUGIN_PACKAGE_NAME;
+    }
+    if (isPackageImportResolvable(LENS_PLUGIN_FALLBACK_PACKAGE)) {
+        return LENS_PLUGIN_FALLBACK_PACKAGE;
+    }
+    const helperDir = path.dirname(fileURLToPath(import.meta.url));
+    const packageRoot = path.resolve(helperDir, "..", "..");
+    const nodeModulesSourceEntry = path.resolve(packageRoot, "node_modules", "@elizaos-plugins", "client-lens", "src", "index.ts");
+    if (existsSync(nodeModulesSourceEntry)) {
+        return pathToFileURL(nodeModulesSourceEntry).href;
+    }
+    const nodeModulesDistEntry = path.resolve(packageRoot, "node_modules", "@elizaos-plugins", "client-lens", "dist", "index.js");
+    if (existsSync(nodeModulesDistEntry)) {
+        return pathToFileURL(nodeModulesDistEntry).href;
+    }
+    for (const relativeEntryPath of LENS_PLUGIN_LOCAL_ENTRY_CANDIDATES) {
+        const absoluteEntryPath = path.resolve(packageRoot, relativeEntryPath);
+        if (existsSync(absoluteEntryPath)) {
+            return pathToFileURL(absoluteEntryPath).href;
+        }
+    }
+    return null;
+}
+const FARCASTER_PLUGIN_PACKAGE_NAME = "@elizaos/plugin-farcaster";
+const FARCASTER_PLUGIN_LOCAL_ENTRY_CANDIDATES = [
+    "../plugins/plugin-farcaster/dist/node/index.node.js",
+];
+/**
+ * Resolve the Farcaster plugin import specifier.
+ * Prefers package resolution, then falls back to local plugin checkout paths.
+ */
+export function resolveFarcasterPluginImportSpecifier() {
+    if (isPackageImportResolvable(FARCASTER_PLUGIN_PACKAGE_NAME)) {
+        return FARCASTER_PLUGIN_PACKAGE_NAME;
+    }
+    const helperDir = path.dirname(fileURLToPath(import.meta.url));
+    const packageRoot = path.resolve(helperDir, "..", "..");
+    for (const relativeEntryPath of FARCASTER_PLUGIN_LOCAL_ENTRY_CANDIDATES) {
+        const absoluteEntryPath = path.resolve(packageRoot, relativeEntryPath);
+        if (existsSync(absoluteEntryPath)) {
+            return pathToFileURL(absoluteEntryPath).href;
+        }
+    }
+    return null;
+}
+const NOSTR_PLUGIN_PACKAGE_NAME = "@elizaos/plugin-nostr";
+const NOSTR_PLUGIN_LOCAL_ENTRY_CANDIDATES = [
+    "../plugins/plugin-nostr/dist/index",
+];
+/**
+ * Resolve the Nostr plugin import specifier.
+ * Prefers package resolution, then falls back to local plugin checkout paths.
+ */
+export function resolveNostrPluginImportSpecifier() {
+    if (isPackageImportResolvable(NOSTR_PLUGIN_PACKAGE_NAME)) {
+        return NOSTR_PLUGIN_PACKAGE_NAME;
+    }
+    const helperDir = path.dirname(fileURLToPath(import.meta.url));
+    const packageRoot = path.resolve(helperDir, "..", "..");
+    for (const relativeEntryPath of NOSTR_PLUGIN_LOCAL_ENTRY_CANDIDATES) {
+        const absoluteEntryPath = path.resolve(packageRoot, relativeEntryPath);
+        if (existsSync(absoluteEntryPath)) {
+            return pathToFileURL(absoluteEntryPath).href;
+        }
+    }
+    return null;
+}
+const MATRIX_PLUGIN_PACKAGE_NAME = "@elizaos/plugin-matrix";
+const MATRIX_PLUGIN_LOCAL_ENTRY_CANDIDATES = [
+    "../plugins/plugin-matrix/dist/index",
+];
+/**
+ * Resolve the Matrix plugin import specifier.
+ * Prefers package resolution, then falls back to local plugin checkout paths.
+ */
+export function resolveMatrixPluginImportSpecifier() {
+    if (isPackageImportResolvable(MATRIX_PLUGIN_PACKAGE_NAME)) {
+        return MATRIX_PLUGIN_PACKAGE_NAME;
+    }
+    const helperDir = path.dirname(fileURLToPath(import.meta.url));
+    const packageRoot = path.resolve(helperDir, "..", "..");
+    for (const relativeEntryPath of MATRIX_PLUGIN_LOCAL_ENTRY_CANDIDATES) {
+        const absoluteEntryPath = path.resolve(packageRoot, relativeEntryPath);
+        if (existsSync(absoluteEntryPath)) {
+            return pathToFileURL(absoluteEntryPath).href;
+        }
+    }
+    return null;
+}
+const FEISHU_PLUGIN_PACKAGE_NAME = "@elizaos/plugin-feishu";
+const FEISHU_PLUGIN_LOCAL_ENTRY_CANDIDATES = [
+    "../plugins/plugin-feishu/dist/index",
+];
+/**
+ * Resolve the Feishu plugin import specifier.
+ * Prefers package resolution, then falls back to local plugin checkout paths.
+ */
+export function resolveFeishuPluginImportSpecifier() {
+    if (isPackageImportResolvable(FEISHU_PLUGIN_PACKAGE_NAME)) {
+        return FEISHU_PLUGIN_PACKAGE_NAME;
+    }
+    const helperDir = path.dirname(fileURLToPath(import.meta.url));
+    const packageRoot = path.resolve(helperDir, "..", "..");
+    const nodeModulesDistEntry = path.resolve(packageRoot, "node_modules", "@elizaos", "plugin-feishu", "dist", "index.js");
+    if (existsSync(nodeModulesDistEntry)) {
+        return pathToFileURL(nodeModulesDistEntry).href;
+    }
+    for (const relativeEntryPath of FEISHU_PLUGIN_LOCAL_ENTRY_CANDIDATES) {
+        const absoluteEntryPath = path.resolve(packageRoot, relativeEntryPath);
+        if (existsSync(absoluteEntryPath)) {
+            return pathToFileURL(absoluteEntryPath).href;
+        }
+    }
+    return null;
+}
+const WECHAT_PLUGIN_PACKAGE_NAME = "@elizaos/plugin-wechat";
+const WECHAT_PLUGIN_LEGACY_PACKAGE_NAME = "@elizaai/plugin-wechat";
+const WECHAT_PLUGIN_LOCAL_ENTRY_CANDIDATES = [
+    "src/index.ts",
+    "dist/index.js",
+];
+export function resolveWechatPluginImportSpecifier() {
+    if (isPackageImportResolvable(WECHAT_PLUGIN_PACKAGE_NAME)) {
+        return WECHAT_PLUGIN_PACKAGE_NAME;
+    }
+    if (isPackageImportResolvable(WECHAT_PLUGIN_LEGACY_PACKAGE_NAME)) {
+        return WECHAT_PLUGIN_LEGACY_PACKAGE_NAME;
+    }
+    const helperDir = path.dirname(fileURLToPath(import.meta.url));
+    const packageRoot = path.resolve(helperDir, "..", "..");
+    // Check node_modules for either the canonical or legacy package name.
+    for (const packageName of [
+        WECHAT_PLUGIN_PACKAGE_NAME,
+        WECHAT_PLUGIN_LEGACY_PACKAGE_NAME,
+    ]) {
+        const packageSegments = packageName.split("/");
+        for (const relativeEntryPath of WECHAT_PLUGIN_LOCAL_ENTRY_CANDIDATES) {
+            const nodeModulesEntry = path.resolve(packageRoot, "node_modules", ...packageSegments, relativeEntryPath);
+            if (existsSync(nodeModulesEntry)) {
+                return pathToFileURL(nodeModulesEntry).href;
+            }
+        }
+    }
+    for (const relativeEntryPath of WECHAT_PLUGIN_LOCAL_ENTRY_CANDIDATES) {
+        const nodeModulesEntry = path.resolve(packageRoot, "node_modules", "@elizaos", "plugin-wechat", relativeEntryPath);
+        if (existsSync(nodeModulesEntry)) {
+            return pathToFileURL(nodeModulesEntry).href;
+        }
+    }
+    return null;
+}
+/** Build a mock update check result with deterministic defaults. */
+export function buildMockUpdateCheckResult(overrides = {}) {
+    return {
+        updateAvailable: false,
+        currentVersion: "2.0.0",
+        latestVersion: "2.0.0",
+        channel: "stable",
+        distTag: "latest",
+        cached: false,
+        error: null,
+        ...overrides,
+    };
+}
+/** Small utility to wait for asynchronous side-effects in tests. */
+export function waitMs(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/** Create a lightweight mocked HTTP response used by handler tests. */
+export function createMockHttpResponse() {
+    let statusCode = 200;
+    let legacyStatus = 0;
+    let payload = "";
+    const res = {
+        set statusCode(value) {
+            statusCode = value;
+            legacyStatus = value;
+        },
+        get statusCode() {
+            return statusCode;
+        },
+        _status: legacyStatus,
+        _body: payload,
+        setHeader: () => undefined,
+        writeHead: (value) => {
+            statusCode = value;
+            legacyStatus = value;
+        },
+        end: (chunk) => {
+            payload = chunk ? chunk.toString() : "";
+            res._body = payload;
+            legacyStatus = statusCode;
+            res._status = legacyStatus;
+        },
+    };
+    return {
+        res,
+        getStatus: () => statusCode,
+        getJson: () => (payload ? JSON.parse(payload) : null),
+    };
+}
+export function createMockHeadersRequest(headers = {}, options = {}) {
+    return createMockIncomingMessage({
+        ...options,
+        headers,
+    });
+}
+export function createMockIncomingMessage({ method = "GET", url = "/", headers = { host: "localhost:2138" }, body, bodyChunks, json = false, }) {
+    const req = new EventEmitter();
+    req.method = method;
+    req.url = url;
+    req.headers = headers;
+    req.destroy = ((_) => req);
+    const chunks = [];
+    if (bodyChunks !== undefined) {
+        for (const chunk of bodyChunks) {
+            chunks.push(typeof chunk === "string" ? Buffer.from(chunk, "utf-8") : chunk);
+        }
+    }
+    else if (body !== undefined) {
+        const encoded = typeof body === "string"
+            ? Buffer.from(body, "utf-8")
+            : body instanceof Buffer
+                ? body
+                : json
+                    ? Buffer.from(JSON.stringify(body), "utf-8")
+                    : Buffer.from(String(body), "utf-8");
+        chunks.push(encoded);
+    }
+    for (const chunk of chunks) {
+        queueMicrotask(() => req.emit("data", chunk));
+    }
+    queueMicrotask(() => req.emit("end"));
+    return req;
+}
+export function createMockJsonRequest(body, options = {}) {
+    return createMockIncomingMessage({
+        ...options,
+        body,
+        json: true,
+    });
+}
+/** Return true when optional plugin imports are intentionally unavailable in this env. */
+export function isOptionalImportError(error, extraMarkers = []) {
+    const message = error instanceof Error ? error.message : String(error);
+    return OPTIONAL_IMPORT_ERROR_MARKERS.concat(extraMarkers).some((marker) => message.includes(marker));
+}
+/** Safely import optional plugin modules while allowing hard failures to bubble. */
+export async function tryOptionalDynamicImport(moduleName, markers) {
+    try {
+        return (await import(__rewriteRelativeImportExtension(moduleName)));
+    }
+    catch (error) {
+        if (isOptionalImportError(error, markers))
+            return null;
+        throw error;
+    }
+}

package/ui-compat.d.ts

@@ -0,0 +1,3 @@
+export type { AppDetailExtensionComponent, AppDetailExtensionProps, AppOperatorSurfaceComponent, AppOperatorSurfaceFocus, AppOperatorSurfaceProps, AppOperatorSurfaceVariant, AppRunHealthState, AppRunSummary, AppRunViewerAttachment, AppSessionJsonValue, BabylonActivityItem, BabylonAgentGoal, BabylonAgentStatus, BabylonChatMessage, BabylonPredictionMarket, BabylonTeamAgent, BabylonWallet, GameOperatorAction, GameOperatorEvent, GameOperatorShellProps, OverlayApp, OverlayAppContext, SelectedAppRun, SurfaceTone, } from "@elizaos/ui";
+export { Button, client, ElizaClient, formatDetailTimestamp, GameOperatorShell, getAppDetailExtension, getAppOperatorSurface, Input, PagePanel, registerDetailExtension, registerOperatorSurface, registerOverlayApp, Spinner, SurfaceBadge, SurfaceCard, SurfaceEmptyState, SurfaceGrid, SurfaceSection, selectLatestRunForApp, toneForHealthState, toneForStatusText, toneForViewerAttachment, useApp, } from "@elizaos/ui";
+//# sourceMappingURL=ui-compat.d.ts.map

package/ui-compat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ui-compat.d.ts","sourceRoot":"","sources":["../../../../src/ui-compat.ts"],"names":[],"mappings":"AAGA,YAAY,EACV,2BAA2B,EAC3B,uBAAuB,EACvB,2BAA2B,EAC3B,uBAAuB,EACvB,uBAAuB,EACvB,yBAAyB,EACzB,iBAAiB,EACjB,aAAa,EACb,sBAAsB,EACtB,mBAAmB,EACnB,mBAAmB,EACnB,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,uBAAuB,EACvB,gBAAgB,EAChB,aAAa,EACb,kBAAkB,EAClB,iBAAiB,EACjB,sBAAsB,EACtB,UAAU,EACV,iBAAiB,EACjB,cAAc,EACd,WAAW,GACZ,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,MAAM,EACN,MAAM,EACN,WAAW,EACX,qBAAqB,EACrB,iBAAiB,EACjB,qBAAqB,EACrB,qBAAqB,EACrB,KAAK,EACL,SAAS,EACT,uBAAuB,EACvB,uBAAuB,EACvB,kBAAkB,EAClB,OAAO,EACP,YAAY,EACZ,WAAW,EACX,iBAAiB,EACjB,WAAW,EACX,cAAc,EACd,qBAAqB,EACrB,kBAAkB,EAClB,iBAAiB,EACjB,uBAAuB,EACvB,MAAM,GACP,MAAM,aAAa,CAAC"}

package/ui-compat.js

@@ -0,0 +1,3 @@
+// Compatibility exports for app packages that still import app UI helpers from
+// @elizaos/app-core. The implementations live in @elizaos/ui.
+export { Button, client, ElizaClient, formatDetailTimestamp, GameOperatorShell, getAppDetailExtension, getAppOperatorSurface, Input, PagePanel, registerDetailExtension, registerOperatorSurface, registerOverlayApp, Spinner, SurfaceBadge, SurfaceCard, SurfaceEmptyState, SurfaceGrid, SurfaceSection, selectLatestRunForApp, toneForHealthState, toneForStatusText, toneForViewerAttachment, useApp, } from "@elizaos/ui";

package/utils/eliza-root.d.ts

@@ -0,0 +1,9 @@
+type ResolveElizaRootOptions = {
+    cwd?: string;
+    argv1?: string;
+    moduleUrl?: string;
+};
+export declare function resolveElizaPackageRoot(opts: ResolveElizaRootOptions): Promise<string | null>;
+export declare function resolveElizaPackageRootSync(opts: ResolveElizaRootOptions): string | null;
+export {};
+//# sourceMappingURL=eliza-root.d.ts.map

package/utils/eliza-root.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eliza-root.d.ts","sourceRoot":"","sources":["../../../../../src/utils/eliza-root.ts"],"names":[],"mappings":"AA6EA,KAAK,uBAAuB,GAAG;IAC7B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAkBF,wBAAsB,uBAAuB,CAC3C,IAAI,EAAE,uBAAuB,GAC5B,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAWxB;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,uBAAuB,GAC5B,MAAM,GAAG,IAAI,CAWf"}

package/utils/eliza-root.js

@@ -0,0 +1,101 @@
+import fsSync from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const CORE_PACKAGE_NAME = "eliza";
+async function readPackageName(dir) {
+    try {
+        const raw = await fs.readFile(path.join(dir, "package.json"), "utf-8");
+        const parsed = JSON.parse(raw);
+        return typeof parsed.name === "string" ? parsed.name : null;
+    }
+    catch {
+        return null;
+    }
+}
+function readPackageNameSync(dir) {
+    try {
+        const raw = fsSync.readFileSync(path.join(dir, "package.json"), "utf-8");
+        const parsed = JSON.parse(raw);
+        return typeof parsed.name === "string" ? parsed.name : null;
+    }
+    catch {
+        return null;
+    }
+}
+function listAncestorDirs(startDir, maxDepth = 12) {
+    const dirs = [];
+    let current = path.resolve(startDir);
+    for (let i = 0; i < maxDepth; i += 1) {
+        dirs.push(current);
+        const parent = path.dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    return dirs;
+}
+async function findPackageRoot(startDir, maxDepth = 12) {
+    for (const candidate of listAncestorDirs(startDir, maxDepth)) {
+        const name = await readPackageName(candidate);
+        if (name === CORE_PACKAGE_NAME) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function findPackageRootSync(startDir, maxDepth = 12) {
+    for (const candidate of listAncestorDirs(startDir, maxDepth)) {
+        const name = readPackageNameSync(candidate);
+        if (name === CORE_PACKAGE_NAME) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function candidateDirsFromArgv1(argv1) {
+    const normalized = path.resolve(argv1);
+    const candidates = [path.dirname(normalized)];
+    const parts = normalized.split(path.sep);
+    const binIndex = parts.lastIndexOf(".bin");
+    if (binIndex > 0 && parts[binIndex - 1] === "node_modules") {
+        const binName = path.basename(normalized);
+        const nodeModulesDir = parts.slice(0, binIndex).join(path.sep);
+        candidates.push(path.join(nodeModulesDir, binName));
+    }
+    return candidates;
+}
+function candidateDirsFromOptions(opts) {
+    const candidates = [];
+    if (opts.moduleUrl) {
+        candidates.push(path.dirname(fileURLToPath(opts.moduleUrl)));
+    }
+    if (opts.argv1) {
+        candidates.push(...candidateDirsFromArgv1(opts.argv1));
+    }
+    if (opts.cwd) {
+        candidates.push(opts.cwd);
+    }
+    return candidates;
+}
+export async function resolveElizaPackageRoot(opts) {
+    const candidates = candidateDirsFromOptions(opts);
+    for (const candidate of candidates) {
+        const found = await findPackageRoot(candidate);
+        if (found) {
+            return found;
+        }
+    }
+    return null;
+}
+export function resolveElizaPackageRootSync(opts) {
+    const candidates = candidateDirsFromOptions(opts);
+    for (const candidate of candidates) {
+        const found = findPackageRootSync(candidate);
+        if (found) {
+            return found;
+        }
+    }
+    return null;
+}

package/utils/globals.d.ts

@@ -0,0 +1,7 @@
+export declare function setVerbose(v: boolean): void;
+export declare function isVerbose(): boolean;
+export declare function shouldLogVerbose(): boolean;
+export declare function logVerbose(message: string): void;
+export declare function setYes(v: boolean): void;
+export declare function isYes(): boolean;
+//# sourceMappingURL=globals.d.ts.map

package/utils/globals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"globals.d.ts","sourceRoot":"","sources":["../../../../../src/utils/globals.ts"],"names":[],"mappings":"AAuBA,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,QAEpC;AAED,wBAAgB,SAAS,YAExB;AAED,wBAAgB,gBAAgB,YAE/B;AAED,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,QAazC;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,QAEhC;AAED,wBAAgB,KAAK,YAEpB"}

package/utils/globals.js

@@ -0,0 +1,47 @@
+import { logger } from "@elizaos/core";
+import { theme } from "@elizaos/shared";
+const LOG_LEVEL_PRIORITY = {
+    trace: 10,
+    debug: 20,
+    info: 30,
+    warn: 40,
+    error: 50,
+    fatal: 60,
+    silent: 100,
+};
+function isLogLevelEnabled(level) {
+    const current = (process.env.LOG_LEVEL ?? "info").toLowerCase();
+    return ((LOG_LEVEL_PRIORITY[level] ?? 30) >= (LOG_LEVEL_PRIORITY[current] ?? 30));
+}
+let globalVerbose = false;
+let globalYes = false;
+export function setVerbose(v) {
+    globalVerbose = v;
+}
+export function isVerbose() {
+    return globalVerbose;
+}
+export function shouldLogVerbose() {
+    return globalVerbose || isLogLevelEnabled("debug");
+}
+export function logVerbose(message) {
+    if (!shouldLogVerbose()) {
+        return;
+    }
+    try {
+        logger.debug({ message }, "verbose");
+    }
+    catch {
+        // ignore logger failures to avoid breaking verbose printing
+    }
+    if (!globalVerbose) {
+        return;
+    }
+    console.log(theme.muted(message));
+}
+export function setYes(v) {
+    globalYes = v;
+}
+export function isYes() {
+    return globalYes;
+}

package/App.d.ts

@@ -1,5 +0,0 @@
-/**
- * Root App component — routing shell.
- */
-export declare function App(): import("react/jsx-runtime").JSX.Element;
-//# sourceMappingURL=App.d.ts.map

package/App.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"App.d.ts","sourceRoot":"","sources":["../src/App.tsx"],"names":[],"mappings":"AAAA;;GAEG;AAyLH,wBAAgB,GAAG,4CAwTlB"}