@elizaos/agent 0.25.9 → 2.0.0-alpha.151

package/packages/agent/src/config/character-schema.d.ts

@@ -0,0 +1,25 @@
+import { z } from "zod";
+export declare const CharacterSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    username: z.ZodOptional<z.ZodString>;
+    bio: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    system: z.ZodOptional<z.ZodString>;
+    adjectives: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    topics: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    style: z.ZodOptional<z.ZodObject<{
+        all: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        chat: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        post: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    messageExamples: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        examples: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            content: z.ZodObject<{
+                text: z.ZodString;
+                actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+    postExamples: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+//# sourceMappingURL=character-schema.d.ts.map

package/packages/agent/src/config/character-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"character-schema.d.ts","sourceRoot":"","sources":["../../../../../src/config/character-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA+BxB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;kBAYjB,CAAC"}

package/packages/agent/src/config/character-schema.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+const MessageExampleContentSchema = z
+    .object({
+    text: z.string().min(1),
+    actions: z.array(z.string()).optional(),
+})
+    .strict();
+const MessageExampleSchema = z
+    .object({
+    name: z.string().min(1),
+    content: MessageExampleContentSchema,
+})
+    .strict();
+const MessageExampleGroupSchema = z
+    .object({
+    examples: z.array(MessageExampleSchema).min(1),
+})
+    .strict();
+const CharacterStyleSchema = z
+    .object({
+    all: z.array(z.string()).optional(),
+    chat: z.array(z.string()).optional(),
+    post: z.array(z.string()).optional(),
+})
+    .strict()
+    .optional();
+export const CharacterSchema = z
+    .object({
+    name: z.string().min(1).max(100).optional(),
+    username: z.string().max(50).optional(),
+    bio: z.union([z.string(), z.array(z.string())]).optional(),
+    system: z.string().max(10000).optional(),
+    adjectives: z.array(z.string().min(1).max(100)).optional(),
+    topics: z.array(z.string().min(1).max(100)).optional(),
+    style: CharacterStyleSchema,
+    messageExamples: z.array(MessageExampleGroupSchema).optional(),
+    postExamples: z.array(z.string()).optional(),
+})
+    .strict();

package/packages/agent/src/config/config.d.ts

@@ -0,0 +1,6 @@
+import type { ElizaConfig } from "./types.js";
+export * from "./types.js";
+export declare function loadElizaConfig(): ElizaConfig;
+export declare function saveElizaConfig(config: ElizaConfig): void;
+export declare function configFileExists(): boolean;
+//# sourceMappingURL=config.d.ts.map

package/packages/agent/src/config/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../../../src/config/config.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,cAAc,YAAY,CAAC;AAuE3B,wBAAgB,eAAe,IAAI,WAAW,CAoH7C;AAwDD,wBAAgB,eAAe,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CA2EzD;AAED,wBAAgB,gBAAgB,IAAI,OAAO,CAQ1C"}

package/packages/agent/src/config/config.js

@@ -0,0 +1,277 @@
+import fs from "node:fs";
+import path from "node:path";
+import { isElizaSettingsDebugEnabled, migrateLegacyRuntimeConfig, sanitizeForSettingsDebug, settingsDebugCloudSummary, } from "@elizaos/shared";
+import JSON5 from "json5";
+import { readConfigEnvSync } from "../api/config-env.js";
+import { syncSolanaPublicKeyEnv } from "../api/wallet-env-sync.js";
+import { collectConfigEnvVars, collectConnectorEnvVars } from "./env-vars.js";
+import { resolveConfigIncludes } from "./includes.js";
+import { resolveConfigPath, resolveStateDir, resolveUserPath, } from "./paths.js";
+export * from "./types.js";
+function resolveConfigWritePath(env = process.env) {
+    const persistPath = env.MILADY_PERSIST_CONFIG_PATH?.trim() ??
+        env.ELIZA_PERSIST_CONFIG_PATH?.trim();
+    return persistPath ? resolveUserPath(persistPath) : resolveConfigPath();
+}
+function applyConfigEnvToProcessEnv(entries) {
+    for (const [key, value] of Object.entries(entries)) {
+        process.env[key] = value;
+    }
+}
+function getConfigEnvString(config, key) {
+    const envConfig = config.env;
+    const nestedVars = envConfig?.vars &&
+        typeof envConfig.vars === "object" &&
+        !Array.isArray(envConfig.vars)
+        ? envConfig.vars
+        : undefined;
+    const value = nestedVars?.[key] ?? envConfig?.[key];
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeConfigRecords(base, overlay) {
+    if (overlay === undefined) {
+        return base;
+    }
+    if (Array.isArray(overlay)) {
+        return overlay.slice();
+    }
+    if (isPlainObject(base) && isPlainObject(overlay)) {
+        const merged = { ...base };
+        for (const [key, value] of Object.entries(overlay)) {
+            merged[key] = mergeConfigRecords(base[key], value);
+        }
+        return merged;
+    }
+    return overlay;
+}
+function readConfigFile(configPath) {
+    let raw;
+    try {
+        raw = fs.readFileSync(configPath, "utf-8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            return null;
+        }
+        throw err;
+    }
+    const parsed = JSON5.parse(raw);
+    return resolveConfigIncludes(parsed, configPath);
+}
+export function loadElizaConfig() {
+    const configPath = resolveConfigPath();
+    const persistPath = resolveConfigWritePath();
+    const baseConfig = readConfigFile(configPath);
+    const persistedConfig = persistPath !== configPath ? readConfigFile(persistPath) : null;
+    const resolved = (baseConfig || persistedConfig
+        ? mergeConfigRecords(baseConfig ?? {}, persistedConfig ?? {})
+        : { logging: { level: "error" } });
+    migrateLegacyRuntimeConfig(resolved);
+    const skillsJsonPath = path.join(resolveStateDir(), "skills.json");
+    if (!fs.existsSync(skillsJsonPath)) {
+        try {
+            const skillsDir = path.dirname(skillsJsonPath);
+            if (!fs.existsSync(skillsDir)) {
+                fs.mkdirSync(skillsDir, { recursive: true });
+            }
+            fs.writeFileSync(skillsJsonPath, JSON.stringify({ extraDirs: [] }, null, 2), "utf-8");
+        }
+        catch (err) {
+            console.warn(`[eliza] Failed to auto-create ~/.eliza/skills.json: ${String(err)}`);
+        }
+    }
+    if (fs.existsSync(skillsJsonPath)) {
+        try {
+            const skillsRaw = fs.readFileSync(skillsJsonPath, "utf-8");
+            const skillsConfig = JSON5.parse(skillsRaw);
+            if (skillsConfig.extraDirs &&
+                Array.isArray(skillsConfig.extraDirs) &&
+                skillsConfig.extraDirs.length > 0) {
+                if (!resolved.skills)
+                    resolved.skills = {};
+                if (!resolved.skills.load)
+                    resolved.skills.load = {};
+                if (!resolved.skills.load.extraDirs) {
+                    resolved.skills.load.extraDirs = [];
+                }
+                const existing = new Set(resolved.skills.load.extraDirs);
+                for (const dir of skillsConfig.extraDirs) {
+                    const loadedDir = resolveUserPath(dir);
+                    if (!existing.has(loadedDir)) {
+                        resolved.skills.load.extraDirs.push(loadedDir);
+                        existing.add(loadedDir);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.warn(`[eliza] Failed to load ~/.eliza/skills.json: ${String(err)}`);
+        }
+    }
+    if (!resolved.logging) {
+        resolved.logging = { level: "error" };
+    }
+    else if (!resolved.logging.level) {
+        resolved.logging.level = "error";
+    }
+    const persistedConfigEnv = readConfigEnvSync(resolveStateDir());
+    // SECURITY: Do NOT merge persistedConfigEnv into resolved.env — config.env
+    // is the designated escape hatch for secrets that must NOT be serialized to
+    // milady.json (e.g. MILADY_CLOUD_CLIENT_ADDRESS_KEY, WALLET_SOURCE_*).
+    // Merging would create a sensitive-data boundary violation.
+    // Instead, apply directly to process.env (below).
+    const envVars = collectConfigEnvVars(resolved);
+    const connectorEnvVars = collectConnectorEnvVars(resolved);
+    // Saved config is the source of truth for settings edited in the app.
+    // If a key is persisted here, it should override any stale value that
+    // arrived from .env or the parent shell.
+    applyConfigEnvToProcessEnv(envVars);
+    applyConfigEnvToProcessEnv(connectorEnvVars);
+    applyConfigEnvToProcessEnv(persistedConfigEnv);
+    const discordToken = process.env.DISCORD_API_TOKEN?.trim() ||
+        process.env.DISCORD_BOT_TOKEN?.trim();
+    if (discordToken) {
+        process.env.DISCORD_API_TOKEN = discordToken;
+        process.env.DISCORD_BOT_TOKEN = discordToken;
+    }
+    // Keep public-key aliases available when only the private key is configured.
+    syncSolanaPublicKeyEnv(getConfigEnvString(resolved, "SOLANA_PRIVATE_KEY"));
+    if (isElizaSettingsDebugEnabled()) {
+        const cloud = resolved.cloud;
+        console.debug("[eliza][settings][loadElizaConfig]", {
+            path: configPath,
+            persistPath: persistPath !== configPath ? persistPath : undefined,
+            topLevelKeys: Object.keys(resolved).sort(),
+            cloud: settingsDebugCloudSummary(cloud),
+            envVarKeysHydrated: Object.keys({
+                ...persistedConfigEnv,
+                ...envVars,
+                ...connectorEnvVars,
+            }).sort(),
+            snapshot: sanitizeForSettingsDebug(resolved),
+        });
+    }
+    return resolved;
+}
+function stripIncludeDirectives(value) {
+    if (value === null || value === undefined)
+        return value;
+    if (Array.isArray(value))
+        return value.map(stripIncludeDirectives);
+    if (typeof value !== "object")
+        return value;
+    const result = {};
+    for (const [key, val] of Object.entries(value)) {
+        if (key === "$include")
+            continue;
+        result[key] = stripIncludeDirectives(val);
+    }
+    return result;
+}
+function isWalletOsStoreEnabledInConfig(config) {
+    const envConfig = config.env;
+    if (!envConfig || typeof envConfig !== "object" || Array.isArray(envConfig)) {
+        return false;
+    }
+    const raw = envConfig.ELIZA_WALLET_OS_STORE;
+    if (typeof raw !== "string") {
+        return false;
+    }
+    const normalized = raw.trim().toLowerCase();
+    return (normalized === "1" ||
+        normalized === "true" ||
+        normalized === "on" ||
+        normalized === "yes");
+}
+function stripWalletPrivateKeysFromConfig(config) {
+    const envConfig = config.env;
+    if (!envConfig || typeof envConfig !== "object" || Array.isArray(envConfig)) {
+        return;
+    }
+    delete envConfig.EVM_PRIVATE_KEY;
+    delete envConfig.SOLANA_PRIVATE_KEY;
+    const nestedVars = envConfig.vars &&
+        typeof envConfig.vars === "object" &&
+        !Array.isArray(envConfig.vars)
+        ? envConfig.vars
+        : undefined;
+    if (nestedVars) {
+        delete nestedVars.EVM_PRIVATE_KEY;
+        delete nestedVars.SOLANA_PRIVATE_KEY;
+    }
+}
+export function saveElizaConfig(config) {
+    const configPath = resolveConfigWritePath();
+    const dir = path.dirname(configPath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+    migrateLegacyRuntimeConfig(config);
+    if (isWalletOsStoreEnabledInConfig(config)) {
+        stripWalletPrivateKeysFromConfig(config);
+    }
+    const sanitized = stripIncludeDirectives(config);
+    if (!sanitized || typeof sanitized !== "object") {
+        throw new Error(`[eliza-config] stripIncludeDirectives returned invalid result: ${typeof sanitized}`);
+    }
+    migrateLegacyRuntimeConfig(sanitized);
+    if (isWalletOsStoreEnabledInConfig(sanitized)) {
+        stripWalletPrivateKeysFromConfig(sanitized);
+    }
+    const content = `${JSON.stringify(sanitized, null, 2)}\n`;
+    // Atomic write: write to a temp file then rename. If the process crashes
+    // during writeFileSync, only the temp file is corrupted — the original
+    // config remains intact. rename() is atomic on POSIX filesystems when
+    // source and destination are on the same filesystem.
+    //
+    // Resolve symlinks so dotfile-managed setups (symlinked config) update
+    // the target file instead of replacing the symlink with a regular file.
+    const realConfigPath = fs.existsSync(configPath)
+        ? fs.realpathSync(configPath)
+        : configPath;
+    const tmpPath = `${realConfigPath}.tmp.${process.pid}`;
+    fs.writeFileSync(tmpPath, content, {
+        encoding: "utf-8",
+        mode: 0o600,
+    });
+    fs.renameSync(tmpPath, realConfigPath);
+    // Enforce 600 on every write — writeFileSync's mode only applies on
+    // creation, so files created by older versions retain their original
+    // (potentially world-readable) permissions.
+    try {
+        fs.chmodSync(configPath, 0o600);
+    }
+    catch {
+        // chmodSync may fail on some platforms (e.g. Windows). Non-fatal.
+    }
+    if (!fs.existsSync(configPath)) {
+        throw new Error(`[eliza-config] Config file missing after write: ${configPath}`);
+    }
+    const stat = fs.statSync(configPath);
+    if (stat.size === 0) {
+        throw new Error(`[eliza-config] Config file is empty after write: ${configPath}`);
+    }
+    if (isElizaSettingsDebugEnabled()) {
+        const c = sanitized;
+        const cloud = c.cloud;
+        console.debug("[eliza][settings][saveElizaConfig]", {
+            path: configPath,
+            bytes: stat.size,
+            topLevelKeys: Object.keys(c).sort(),
+            cloud: settingsDebugCloudSummary(cloud),
+            snapshot: sanitizeForSettingsDebug(sanitized),
+        });
+    }
+}
+export function configFileExists() {
+    const configPath = resolveConfigPath();
+    if (fs.existsSync(configPath)) {
+        return true;
+    }
+    const persistPath = resolveConfigWritePath();
+    return persistPath !== configPath && fs.existsSync(persistPath);
+}
+// Backward-compat aliases for downstream forks using the old name

package/packages/agent/src/config/env-vars.d.ts

@@ -0,0 +1,9 @@
+import type { ElizaConfig } from "./types.js";
+/**
+ * Maps connector config fields to the environment variables expected by
+ * elizaOS plugins. Keep this aligned with runtime/eliza.ts.
+ */
+export declare const CONNECTOR_ENV_MAP: Readonly<Record<string, Readonly<Record<string, string>>>>;
+export declare function collectConfigEnvVars(cfg?: ElizaConfig): Record<string, string>;
+export declare function collectConnectorEnvVars(cfg?: ElizaConfig): Record<string, string>;
+//# sourceMappingURL=env-vars.d.ts.map

package/packages/agent/src/config/env-vars.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env-vars.d.ts","sourceRoot":"","sources":["../../../../../src/config/env-vars.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAoD9C;;;GAGG;AACH,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CACtC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAuFjD,CAAC;AAEF,wBAAgB,oBAAoB,CAClC,GAAG,CAAC,EAAE,WAAW,GAChB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAkCxB;AAED,wBAAgB,uBAAuB,CACrC,GAAG,CAAC,EAAE,WAAW,GAChB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAsIxB"}

package/packages/agent/src/config/env-vars.js

@@ -0,0 +1,282 @@
+/**
+ * Environment variable keys that must NEVER be synced from config → process.env.
+ *
+ * Mirrors the BLOCKED_ENV_KEYS set in server.ts.  This is a defense-in-depth
+ * gate: even if a blocked key is somehow persisted into eliza.config.json
+ * (e.g. via an API bypass or manual file edit), it will not be loaded into the
+ * process environment on startup.
+ *
+ * Categories:
+ *   - Process-level code injection (NODE_OPTIONS, LD_PRELOAD, …)
+ *   - TLS / proxy hijack (NODE_TLS_REJECT_UNAUTHORIZED, HTTP_PROXY, …)
+ *   - Module resolution (NODE_PATH)
+ *   - Privilege escalation tokens (ELIZA_API_TOKEN, …)
+ *   - Wallet private keys
+ *   - System paths
+ */
+const BLOCKED_STARTUP_ENV_KEYS = new Set([
+    "LD_PRELOAD",
+    "LD_LIBRARY_PATH",
+    "DYLD_INSERT_LIBRARIES",
+    "DYLD_LIBRARY_PATH",
+    "NODE_OPTIONS",
+    "NODE_EXTRA_CA_CERTS",
+    "NODE_TLS_REJECT_UNAUTHORIZED",
+    "HTTP_PROXY",
+    "HTTPS_PROXY",
+    "ALL_PROXY",
+    "NO_PROXY",
+    "NODE_PATH",
+    "SSL_CERT_FILE",
+    "SSL_CERT_DIR",
+    "CURL_CA_BUNDLE",
+    "PATH",
+    "HOME",
+    "SHELL",
+    "ELIZA_API_TOKEN",
+    "ELIZA_API_TOKEN",
+    "ELIZA_WALLET_EXPORT_TOKEN",
+    "ELIZA_WALLET_EXPORT_TOKEN",
+    "ELIZA_TERMINAL_RUN_TOKEN",
+    "ELIZA_TERMINAL_RUN_TOKEN",
+    "HYPERSCAPE_AUTH_TOKEN",
+    "EVM_PRIVATE_KEY",
+    "SOLANA_PRIVATE_KEY",
+    "MILADY_CLOUD_CLIENT_ADDRESS_KEY",
+    "GITHUB_TOKEN",
+    "DATABASE_URL",
+    "POSTGRES_URL",
+]);
+/**
+ * Maps connector config fields to the environment variables expected by
+ * elizaOS plugins. Keep this aligned with runtime/eliza.ts.
+ */
+export const CONNECTOR_ENV_MAP = {
+    bluebubbles: {
+        enabled: "BLUEBUBBLES_ENABLED",
+        serverUrl: "BLUEBUBBLES_SERVER_URL",
+        password: "BLUEBUBBLES_PASSWORD",
+        webhookPath: "BLUEBUBBLES_WEBHOOK_PATH",
+        autoStartCommand: "BLUEBUBBLES_AUTOSTART_COMMAND",
+        autoStartArgs: "BLUEBUBBLES_AUTOSTART_ARGS",
+        autoStartCwd: "BLUEBUBBLES_AUTOSTART_CWD",
+        autoStartWaitMs: "BLUEBUBBLES_AUTOSTART_WAIT_MS",
+        dmPolicy: "BLUEBUBBLES_DM_POLICY",
+        groupPolicy: "BLUEBUBBLES_GROUP_POLICY",
+        allowFrom: "BLUEBUBBLES_ALLOW_FROM",
+        groupAllowFrom: "BLUEBUBBLES_GROUP_ALLOW_FROM",
+        sendReadReceipts: "BLUEBUBBLES_SEND_READ_RECEIPTS",
+    },
+    discord: {
+        token: "DISCORD_API_TOKEN",
+        botToken: "DISCORD_API_TOKEN",
+        applicationId: "DISCORD_APPLICATION_ID",
+        syncProfile: "DISCORD_SYNC_PROFILE",
+        profileName: "DISCORD_PROFILE_NAME",
+        profileAvatar: "DISCORD_PROFILE_AVATAR",
+    },
+    discordLocal: {
+        enabled: "DISCORD_LOCAL_ENABLED",
+        clientId: "DISCORD_LOCAL_CLIENT_ID",
+        clientSecret: "DISCORD_LOCAL_CLIENT_SECRET",
+        scopes: "DISCORD_LOCAL_SCOPES",
+        messageChannelIds: "DISCORD_LOCAL_MESSAGE_CHANNEL_IDS",
+        sendDelayMs: "DISCORD_LOCAL_SEND_DELAY_MS",
+    },
+    telegram: {
+        botToken: "TELEGRAM_BOT_TOKEN",
+    },
+    telegramAccount: {
+        phone: "TELEGRAM_ACCOUNT_PHONE",
+        appId: "TELEGRAM_ACCOUNT_APP_ID",
+        appHash: "TELEGRAM_ACCOUNT_APP_HASH",
+        deviceModel: "TELEGRAM_ACCOUNT_DEVICE_MODEL",
+        systemVersion: "TELEGRAM_ACCOUNT_SYSTEM_VERSION",
+    },
+    slack: {
+        botToken: "SLACK_BOT_TOKEN",
+        appToken: "SLACK_APP_TOKEN",
+        userToken: "SLACK_USER_TOKEN",
+    },
+    signal: {
+        authDir: "SIGNAL_AUTH_DIR",
+        account: "SIGNAL_ACCOUNT_NUMBER",
+        httpUrl: "SIGNAL_HTTP_URL",
+        cliPath: "SIGNAL_CLI_PATH",
+    },
+    imessage: {
+        enabled: "IMESSAGE_ENABLED",
+        cliPath: "IMESSAGE_CLI_PATH",
+        dbPath: "IMESSAGE_DB_PATH",
+        dmPolicy: "IMESSAGE_DM_POLICY",
+        groupPolicy: "IMESSAGE_GROUP_POLICY",
+        allowFrom: "IMESSAGE_ALLOW_FROM",
+        pollIntervalMs: "IMESSAGE_POLL_INTERVAL_MS",
+    },
+    whatsapp: {
+        authDir: "WHATSAPP_AUTH_DIR",
+        sessionPath: "WHATSAPP_AUTH_DIR",
+        dmPolicy: "WHATSAPP_DM_POLICY",
+        groupPolicy: "WHATSAPP_GROUP_POLICY",
+    },
+    msteams: {
+        appId: "MSTEAMS_APP_ID",
+        appPassword: "MSTEAMS_APP_PASSWORD",
+    },
+    mattermost: {
+        botToken: "MATTERMOST_BOT_TOKEN",
+        baseUrl: "MATTERMOST_BASE_URL",
+    },
+    googlechat: {
+        serviceAccountKey: "GOOGLE_CHAT_SERVICE_ACCOUNT_KEY",
+    },
+    blooio: {
+        apiKey: "BLOOIO_API_KEY",
+        fromNumber: "BLOOIO_PHONE_NUMBER",
+        webhookSecret: "BLOOIO_WEBHOOK_SECRET",
+        webhookUrl: "BLOOIO_WEBHOOK_URL",
+        webhookPort: "BLOOIO_WEBHOOK_PORT",
+    },
+};
+export function collectConfigEnvVars(cfg) {
+    const envConfig = cfg?.env;
+    if (!envConfig) {
+        return {};
+    }
+    const entries = {};
+    if (envConfig.vars) {
+        for (const [key, value] of Object.entries(envConfig.vars)) {
+            if (!value) {
+                continue;
+            }
+            if (BLOCKED_STARTUP_ENV_KEYS.has(key.toUpperCase())) {
+                continue;
+            }
+            entries[key] = value;
+        }
+    }
+    for (const [key, value] of Object.entries(envConfig)) {
+        if (key === "shellEnv" || key === "vars") {
+            continue;
+        }
+        if (typeof value !== "string" || !value.trim()) {
+            continue;
+        }
+        if (BLOCKED_STARTUP_ENV_KEYS.has(key.toUpperCase())) {
+            continue;
+        }
+        entries[key] = value;
+    }
+    return entries;
+}
+export function collectConnectorEnvVars(cfg) {
+    const rawConnectors = cfg?.connectors ?? cfg?.channels;
+    if (!rawConnectors ||
+        typeof rawConnectors !== "object" ||
+        Array.isArray(rawConnectors)) {
+        return {};
+    }
+    const connectors = rawConnectors;
+    const entries = {};
+    for (const [connectorName, envMap] of Object.entries(CONNECTOR_ENV_MAP)) {
+        const connectorConfig = connectors[connectorName];
+        if (!connectorConfig ||
+            typeof connectorConfig !== "object" ||
+            Array.isArray(connectorConfig)) {
+            continue;
+        }
+        const configObj = connectorConfig;
+        // Mirror Discord token aliases so older plugins and settings surfaces
+        // agree on a single configured state.
+        if (connectorName === "discord") {
+            const tokenValue = (typeof configObj.token === "string" && configObj.token.trim()) ||
+                (typeof configObj.botToken === "string" && configObj.botToken.trim()) ||
+                "";
+            if (tokenValue) {
+                entries.DISCORD_API_TOKEN = tokenValue;
+                entries.DISCORD_BOT_TOKEN = tokenValue;
+            }
+        }
+        for (const [configField, envKey] of Object.entries(envMap)) {
+            // Discord token/botToken are handled above with token-first precedence; the
+            // env map maps both fields to DISCORD_API_TOKEN, so applying them here would
+            // let botToken overwrite token.
+            if (connectorName === "discord" &&
+                (configField === "token" || configField === "botToken")) {
+                continue;
+            }
+            const value = configObj[configField];
+            let normalized = null;
+            if (typeof value === "string") {
+                normalized = value.trim() ? value : null;
+            }
+            else if (typeof value === "number" && Number.isFinite(value)) {
+                normalized = String(value);
+            }
+            else if (typeof value === "boolean") {
+                normalized = value ? "true" : "false";
+            }
+            else if (Array.isArray(value)) {
+                const serialized = value
+                    .map((entry) => {
+                    if (typeof entry === "string")
+                        return entry.trim();
+                    if (typeof entry === "number" && Number.isFinite(entry)) {
+                        return String(entry);
+                    }
+                    return "";
+                })
+                    .filter((entry) => entry.length > 0)
+                    .join(",");
+                normalized = serialized.length > 0 ? serialized : null;
+            }
+            if (!normalized) {
+                continue;
+            }
+            if (BLOCKED_STARTUP_ENV_KEYS.has(envKey.toUpperCase())) {
+                continue;
+            }
+            entries[envKey] = normalized;
+        }
+        if (connectorName === "whatsapp") {
+            const allowFrom = configObj.allowFrom;
+            if (Array.isArray(allowFrom) && allowFrom.length > 0) {
+                const normalized = allowFrom
+                    .map((value) => String(value).trim())
+                    .filter(Boolean);
+                if (normalized.length > 0) {
+                    entries.WHATSAPP_ALLOW_FROM = normalized.join(",");
+                }
+            }
+            const groupAllowFrom = configObj.groupAllowFrom;
+            if (Array.isArray(groupAllowFrom) && groupAllowFrom.length > 0) {
+                const normalized = groupAllowFrom
+                    .map((value) => String(value).trim())
+                    .filter(Boolean);
+                if (normalized.length > 0) {
+                    entries.WHATSAPP_GROUP_ALLOW_FROM = normalized.join(",");
+                }
+            }
+            const accounts = configObj.accounts;
+            if (accounts &&
+                typeof accounts === "object" &&
+                !Array.isArray(accounts)) {
+                const firstEnabledAccount = Object.values(accounts).find((account) => {
+                    if (!account ||
+                        typeof account !== "object" ||
+                        Array.isArray(account)) {
+                        return false;
+                    }
+                    const candidate = account;
+                    return (candidate.enabled !== false && typeof candidate.authDir === "string");
+                });
+                if (firstEnabledAccount &&
+                    typeof firstEnabledAccount.authDir === "string" &&
+                    firstEnabledAccount.authDir.trim()) {
+                    entries.WHATSAPP_AUTH_DIR = firstEnabledAccount.authDir.trim();
+                }
+            }
+        }
+    }
+    return entries;
+}

package/packages/agent/src/config/feature-flags.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Centralised readers for Milady feature flags that gate unreleased or
+ * in-progress integrations. Keep this module dependency-free so it can be
+ * imported from any layer (api, runtime, cloud) without cycles.
+ *
+ * Flags live in `process.env` (set via `config.env` on disk). They are read
+ * each call so a runtime restart picks up changes without a module reload.
+ */
+/**
+ * Eliza Cloud remote-signing wallet bridge.
+ *
+ * When on: `POST /api/cloud/login/status` provisions cloud wallets, writes
+ * `WALLET_SOURCE_*`, and the UI exposes a dual-wallet (local | cloud) picker.
+ * When off: zero cloud-wallet code paths run; wallet UI/API behave as before.
+ */
+export declare function isCloudWalletEnabled(): boolean;
+//# sourceMappingURL=feature-flags.d.ts.map

package/packages/agent/src/config/feature-flags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-flags.d.ts","sourceRoot":"","sources":["../../../../../src/config/feature-flags.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAyBH;;;;;;GAMG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CAE9C"}