@elizaos/plugin-commands 2.0.0-beta.1 → 2.0.3-beta.2

package/dist/cjs/index.cjs

@@ -1,822 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toCommonJS = (from) => {
-  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (var key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(entry, key))
-        __defProp(entry, key, {
-          get: __accessProp.bind(from, key),
-          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-        });
-  }
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __moduleCache;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-
-// src/index.ts
-var exports_src = {};
-__export(exports_src, {
-  useRuntime: () => useRuntime,
-  unregisterCommand: () => unregisterCommand,
-  startsWithCommand: () => startsWithCommand,
-  resetCommands: () => resetCommands,
-  registerCommands: () => registerCommands,
-  registerCommand: () => registerCommand,
-  parseCommand: () => parseCommand,
-  normalizeCommandBody: () => normalizeCommandBody,
-  isElevated: () => isElevated,
-  isCommandOnly: () => isCommandOnly,
-  isAuthorized: () => isAuthorized,
-  initForRuntime: () => initForRuntime,
-  hasCommand: () => hasCommand,
-  getEnabledCommands: () => getEnabledCommands,
-  getCommandsByCategory: () => getCommandsByCategory,
-  getCommands: () => getCommands,
-  formatCommandResult: () => formatCommandResult,
-  findCommandByKey: () => findCommandByKey,
-  findCommandByAlias: () => findCommandByAlias,
-  extractCommand: () => extractCommand,
-  detectCommand: () => detectCommand,
-  default: () => src_default,
-  commandsPlugin: () => commandsPlugin,
-  commandRegistryProvider: () => commandRegistryProvider
-});
-module.exports = __toCommonJS(exports_src);
-var import_core = require("@elizaos/core");
-
-// src/registry.ts
-var DEFAULT_COMMANDS = [
-  {
-    key: "help",
-    nativeName: "help",
-    description: "Show available commands",
-    textAliases: ["/help", "/h", "/?"],
-    scope: "both",
-    category: "status",
-    acceptsArgs: false
-  },
-  {
-    key: "commands",
-    nativeName: "commands",
-    description: "List all commands",
-    textAliases: ["/commands", "/cmds"],
-    scope: "both",
-    category: "status",
-    acceptsArgs: false
-  },
-  {
-    key: "status",
-    nativeName: "status",
-    description: "Show current session status",
-    textAliases: ["/status", "/s"],
-    scope: "both",
-    category: "status",
-    acceptsArgs: false
-  },
-  {
-    key: "context",
-    nativeName: "context",
-    description: "Show current context information",
-    textAliases: ["/context", "/ctx"],
-    scope: "both",
-    category: "status",
-    acceptsArgs: true,
-    args: [{ name: "mode", description: "Output mode (list, detail, json)" }]
-  },
-  {
-    key: "whoami",
-    nativeName: "whoami",
-    description: "Show your identity information",
-    textAliases: ["/whoami", "/who"],
-    scope: "both",
-    category: "status",
-    acceptsArgs: false
-  },
-  {
-    key: "stop",
-    nativeName: "stop",
-    description: "Stop current operation",
-    textAliases: ["/stop", "/abort", "/cancel"],
-    scope: "both",
-    category: "session",
-    acceptsArgs: false
-  },
-  {
-    key: "restart",
-    nativeName: "restart",
-    description: "Restart the session",
-    textAliases: ["/restart"],
-    scope: "both",
-    category: "session",
-    acceptsArgs: false,
-    requiresAuth: true
-  },
-  {
-    key: "reset",
-    nativeName: "reset",
-    description: "Reset session state",
-    textAliases: ["/reset"],
-    scope: "both",
-    category: "session",
-    acceptsArgs: false,
-    requiresAuth: true
-  },
-  {
-    key: "new",
-    nativeName: "new",
-    description: "Start a new conversation",
-    textAliases: ["/new"],
-    scope: "both",
-    category: "session",
-    acceptsArgs: false
-  },
-  {
-    key: "compact",
-    nativeName: "compact",
-    description: "Compact conversation history",
-    textAliases: ["/compact"],
-    scope: "both",
-    category: "session",
-    acceptsArgs: true,
-    args: [
-      { name: "instructions", description: "Optional compaction instructions" }
-    ]
-  },
-  {
-    key: "think",
-    nativeName: "think",
-    description: "Set thinking level",
-    textAliases: ["/think", "/thinking", "/t"],
-    scope: "both",
-    category: "options",
-    acceptsArgs: true,
-    args: [
-      { name: "level", description: "off, minimal, low, medium, high, xhigh" }
-    ]
-  },
-  {
-    key: "verbose",
-    nativeName: "verbose",
-    description: "Set verbose output level",
-    textAliases: ["/verbose", "/v"],
-    scope: "both",
-    category: "options",
-    acceptsArgs: true,
-    args: [{ name: "level", description: "off, on, full" }]
-  },
-  {
-    key: "reasoning",
-    nativeName: "reasoning",
-    description: "Set reasoning visibility",
-    textAliases: ["/reasoning", "/reason"],
-    scope: "both",
-    category: "options",
-    acceptsArgs: true,
-    args: [{ name: "level", description: "off, on, stream" }]
-  },
-  {
-    key: "elevated",
-    nativeName: "elevated",
-    description: "Set elevated permission mode",
-    textAliases: ["/elevated", "/elev"],
-    scope: "both",
-    category: "options",
-    acceptsArgs: true,
-    args: [{ name: "level", description: "off, on, ask, full" }],
-    requiresAuth: true
-  },
-  {
-    key: "model",
-    nativeName: "model",
-    description: "Set or show current model",
-    textAliases: ["/model", "/m"],
-    scope: "both",
-    category: "options",
-    acceptsArgs: true,
-    args: [{ name: "model", description: "provider/model or alias" }]
-  },
-  {
-    key: "models",
-    nativeName: "models",
-    description: "List available models",
-    textAliases: ["/models"],
-    scope: "both",
-    category: "options",
-    acceptsArgs: false
-  },
-  {
-    key: "usage",
-    nativeName: "usage",
-    description: "Show token usage",
-    textAliases: ["/usage"],
-    scope: "both",
-    category: "options",
-    acceptsArgs: false
-  },
-  {
-    key: "queue",
-    nativeName: "queue",
-    description: "Set queue mode",
-    textAliases: ["/queue", "/q"],
-    scope: "both",
-    category: "options",
-    acceptsArgs: true,
-    args: [
-      {
-        name: "mode",
-        description: "steer, followup, collect, interrupt, or options"
-      }
-    ]
-  },
-  {
-    key: "allowlist",
-    nativeName: "allowlist",
-    description: "Manage sender allowlist",
-    textAliases: ["/allowlist", "/allow"],
-    scope: "both",
-    category: "management",
-    acceptsArgs: true,
-    args: [
-      { name: "action", description: "list, add, remove" },
-      { name: "value", description: "sender to add/remove" }
-    ],
-    requiresAuth: true
-  },
-  {
-    key: "approve",
-    nativeName: "approve",
-    description: "Approve or deny a pending action",
-    textAliases: ["/approve"],
-    scope: "both",
-    category: "management",
-    acceptsArgs: true,
-    args: [
-      { name: "id", description: "Approval ID", required: true },
-      { name: "action", description: "allow-once, allow-always, deny" }
-    ],
-    requiresAuth: true
-  },
-  {
-    key: "subagents",
-    nativeName: "subagents",
-    description: "Manage subagents",
-    textAliases: ["/subagents", "/sub"],
-    scope: "both",
-    category: "management",
-    acceptsArgs: true,
-    args: [{ name: "action", description: "list, stop, log, info, send" }],
-    requiresAuth: true
-  },
-  {
-    key: "config",
-    nativeName: "config",
-    description: "View or set configuration",
-    textAliases: ["/config", "/cfg"],
-    scope: "both",
-    category: "management",
-    acceptsArgs: true,
-    args: [
-      { name: "key", description: "Configuration key" },
-      { name: "value", description: "Value to set" }
-    ],
-    requiresAuth: true,
-    enabled: false
-  },
-  {
-    key: "debug",
-    nativeName: "debug",
-    description: "Debug information",
-    textAliases: ["/debug"],
-    scope: "both",
-    category: "management",
-    acceptsArgs: true,
-    requiresAuth: true,
-    enabled: false
-  },
-  {
-    key: "tts",
-    nativeName: "tts",
-    description: "Text-to-speech settings",
-    textAliases: ["/tts", "/voice"],
-    scope: "both",
-    category: "media",
-    acceptsArgs: true,
-    args: [
-      {
-        name: "action",
-        description: "on, off, status, provider, limit, audio"
-      }
-    ]
-  },
-  {
-    key: "bash",
-    nativeName: "bash",
-    description: "Execute shell command",
-    textAliases: ["/bash", "/sh", "/!"],
-    scope: "text",
-    category: "tools",
-    acceptsArgs: true,
-    args: [
-      {
-        name: "command",
-        description: "Shell command to execute",
-        captureRemaining: true
-      }
-    ],
-    requiresAuth: true,
-    requiresElevated: true
-  }
-];
-var runtimeStores = new Map;
-var fallbackStore = {
-  commands: DEFAULT_COMMANDS.map((c) => ({ ...c })),
-  aliasMap: null
-};
-var activeStore = fallbackStore;
-function initForRuntime(agentId) {
-  const store = {
-    commands: DEFAULT_COMMANDS.map((c) => ({ ...c })),
-    aliasMap: null
-  };
-  runtimeStores.set(agentId, store);
-  activeStore = store;
-}
-function useRuntime(agentId) {
-  const store = runtimeStores.get(agentId);
-  if (store) {
-    activeStore = store;
-  }
-}
-function getCommands() {
-  return [...activeStore.commands];
-}
-function getEnabledCommands() {
-  return activeStore.commands.filter((cmd) => cmd.enabled !== false);
-}
-function getCommandsByCategory(category) {
-  return activeStore.commands.filter((cmd) => cmd.category === category && cmd.enabled !== false);
-}
-function registerCommand(command) {
-  activeStore.commands = activeStore.commands.filter((c) => c.key !== command.key);
-  activeStore.commands.push(command);
-  activeStore.aliasMap = null;
-}
-function registerCommands(newCommands) {
-  for (const command of newCommands) {
-    registerCommand(command);
-  }
-}
-function unregisterCommand(key) {
-  activeStore.commands = activeStore.commands.filter((c) => c.key !== key);
-  activeStore.aliasMap = null;
-}
-function resetCommands() {
-  activeStore.commands = DEFAULT_COMMANDS.map((c) => ({ ...c }));
-  activeStore.aliasMap = null;
-}
-function getAliasMap() {
-  if (activeStore.aliasMap)
-    return activeStore.aliasMap;
-  activeStore.aliasMap = new Map;
-  for (const command of activeStore.commands) {
-    if (command.enabled === false)
-      continue;
-    for (const alias of command.textAliases) {
-      const normalized = alias.toLowerCase().trim();
-      if (!activeStore.aliasMap.has(normalized)) {
-        activeStore.aliasMap.set(normalized, command);
-      }
-    }
-  }
-  return activeStore.aliasMap;
-}
-function findCommandByAlias(alias) {
-  const map = getAliasMap();
-  return map.get(alias.toLowerCase().trim());
-}
-function findCommandByKey(key) {
-  return activeStore.commands.find((c) => c.key === key);
-}
-function startsWithCommand(text) {
-  const map = getAliasMap();
-  const normalized = text.toLowerCase().trim();
-  for (const [alias, command] of map) {
-    if (normalized === alias) {
-      return command;
-    }
-    if (normalized.startsWith(`${alias} `) || normalized.startsWith(`${alias}:`)) {
-      return command;
-    }
-  }
-  return;
-}
-
-// src/parser.ts
-var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-function hasCommand(text) {
-  if (!text)
-    return false;
-  const trimmed = text.trim();
-  if (!trimmed.startsWith("/") && !trimmed.startsWith("!"))
-    return false;
-  return Boolean(startsWithCommand(trimmed));
-}
-function detectCommand(text) {
-  if (!text) {
-    return { isCommand: false };
-  }
-  const trimmed = text.trim();
-  if (!trimmed.startsWith("/") && !trimmed.startsWith("!")) {
-    return { isCommand: false };
-  }
-  const command = startsWithCommand(trimmed);
-  if (!command) {
-    return { isCommand: false };
-  }
-  const parsed = parseCommand(trimmed, command);
-  if (!parsed) {
-    return { isCommand: false };
-  }
-  return { isCommand: true, command: parsed };
-}
-function parseCommand(text, definition) {
-  const trimmed = text.trim();
-  let matchedAlias = null;
-  for (const alias of definition.textAliases) {
-    const normalized = alias.toLowerCase();
-    if (trimmed.toLowerCase() === normalized) {
-      matchedAlias = alias;
-      break;
-    }
-    if (trimmed.toLowerCase().startsWith(`${normalized} `) || trimmed.toLowerCase().startsWith(`${normalized}:`)) {
-      matchedAlias = alias;
-      break;
-    }
-  }
-  if (!matchedAlias) {
-    return null;
-  }
-  let rawArgs = trimmed.slice(matchedAlias.length).trim();
-  if (rawArgs.startsWith(":")) {
-    rawArgs = rawArgs.slice(1).trim();
-  }
-  const args = parseArgs(rawArgs, definition);
-  return {
-    key: definition.key,
-    canonical: definition.textAliases[0] ?? `/${definition.key}`,
-    args,
-    rawArgs: rawArgs || undefined
-  };
-}
-function parseArgs(rawArgs, definition) {
-  if (!rawArgs || !definition.acceptsArgs) {
-    return [];
-  }
-  const parsing = definition.argsParsing ?? "positional";
-  if (parsing === "none") {
-    return rawArgs ? [rawArgs] : [];
-  }
-  const args = [];
-  const argDefs = definition.args ?? [];
-  const tokens = tokenize(rawArgs);
-  for (let i = 0;i < tokens.length; i++) {
-    const argDef = argDefs[i];
-    if (argDef?.captureRemaining) {
-      args.push(tokens.slice(i).join(" "));
-      break;
-    }
-    args.push(tokens[i]);
-  }
-  return args;
-}
-function tokenize(input) {
-  const tokens = [];
-  let current = "";
-  let inQuote = false;
-  let quoteChar = "";
-  for (let i = 0;i < input.length; i++) {
-    const char = input[i];
-    if (inQuote) {
-      if (char === quoteChar) {
-        inQuote = false;
-        if (current) {
-          tokens.push(current);
-          current = "";
-        }
-      } else {
-        current += char;
-      }
-    } else if (char === '"' || char === "'") {
-      inQuote = true;
-      quoteChar = char;
-    } else if (/\s/.test(char)) {
-      if (current) {
-        tokens.push(current);
-        current = "";
-      }
-    } else {
-      current += char;
-    }
-  }
-  if (current) {
-    tokens.push(current);
-  }
-  return tokens;
-}
-function normalizeCommandBody(text, botMention) {
-  let normalized = text.trim();
-  if (botMention) {
-    const mentionPattern = new RegExp(`^@${escapeRegExp(botMention)}\\s*`, "i");
-    normalized = normalized.replace(mentionPattern, "");
-  }
-  normalized = normalized.replace(/^(\/\w+):\s*/, "$1 ");
-  return normalized.trim();
-}
-function isCommandOnly(text) {
-  const detection = detectCommand(text);
-  if (!detection.isCommand || !detection.command) {
-    return false;
-  }
-  if (!detection.command.rawArgs) {
-    return true;
-  }
-  return detection.command.rawArgs.trim().length === 0;
-}
-function extractCommand(text) {
-  const detection = detectCommand(text);
-  if (!detection.isCommand || !detection.command) {
-    return null;
-  }
-  const { command } = detection;
-  if (!command.rawArgs) {
-    return { command, remainingText: "" };
-  }
-  return { command, remainingText: command.rawArgs };
-}
-
-// src/index.ts
-var commandRegistryProvider = {
-  name: "COMMAND_REGISTRY",
-  description: "Available chat commands and their descriptions",
-  descriptionCompressed: "Available chat commands and descriptions.",
-  dynamic: true,
-  contexts: ["general", "automation"],
-  contextGate: { anyOf: ["general", "automation"] },
-  cacheStable: true,
-  cacheScope: "agent",
-  async get(runtime, message, _state) {
-    useRuntime(runtime.agentId);
-    const text = message.content?.text ?? "";
-    const isCommand = hasCommand(text);
-    const commands = getEnabledCommands();
-    if (isCommand) {
-      const commandList = commands.map((cmd) => {
-        const auth = cmd.requiresAuth ? " (requires auth)" : "";
-        return `- ${cmd.textAliases[0]}: ${cmd.description}${auth}`;
-      });
-      return {
-        text: `The user sent a slash command. Available commands:
-${commandList.join(`
-`)}
-
-IMPORTANT: This is a slash command — respond by executing the matching command action, not with conversational text.`,
-        values: {
-          commandCount: commands.length,
-          isCommand: true,
-          hasElevatedCommands: commands.some((c) => c.requiresElevated)
-        },
-        data: { commands, isCommand: true }
-      };
-    }
-    return {
-      text: "",
-      values: {
-        commandCount: commands.length,
-        isCommand: false
-      },
-      data: { isCommand: false }
-    };
-  }
-};
-function formatCommandResult(result) {
-  if (result.error) {
-    return `Error: ${result.error}`;
-  }
-  return result.reply ?? "Command executed";
-}
-function isAuthorized(context, command) {
-  if (!command.requiresAuth) {
-    return true;
-  }
-  return context.isAuthorized;
-}
-function isElevated(context, command) {
-  if (!command.requiresElevated) {
-    return true;
-  }
-  return context.isElevated;
-}
-var commandsPlugin = {
-  name: "commands",
-  description: "Chat command system with /help, /status, /reset, etc.",
-  providers: [commandRegistryProvider],
-  autoEnable: {
-    shouldEnable: (_env, config) => {
-      const f = config?.features?.commands;
-      return f === true || typeof f === "object" && f !== null && f.enabled !== false;
-    }
-  },
-  config: {
-    COMMANDS_ENABLED: "true",
-    COMMANDS_CONFIG_ENABLED: "false",
-    COMMANDS_DEBUG_ENABLED: "false",
-    COMMANDS_BASH_ENABLED: "false",
-    COMMANDS_RESTART_ENABLED: "true"
-  },
-  tests: [
-    {
-      name: "command-detection",
-      tests: [
-        {
-          name: "Detect command prefix",
-          fn: async (_runtime) => {
-            if (!hasCommand("/help")) {
-              throw new Error("Should detect /help command");
-            }
-            if (!hasCommand("/status test")) {
-              throw new Error("Should detect /status with args");
-            }
-            if (hasCommand("hello world")) {
-              throw new Error("Should not detect plain text as command");
-            }
-            import_core.logger.success("Command prefix detection works correctly");
-          }
-        },
-        {
-          name: "Parse command with args",
-          fn: async (_runtime) => {
-            const detection = detectCommand("/think:high");
-            if (!detection.isCommand) {
-              throw new Error("Should detect think command");
-            }
-            if (detection.command?.key !== "think") {
-              throw new Error(`Expected key 'think', got '${detection.command?.key}'`);
-            }
-            if (detection.command?.args[0] !== "high") {
-              throw new Error(`Expected arg 'high', got '${detection.command?.args[0]}'`);
-            }
-            import_core.logger.success("Command argument parsing works correctly");
-          }
-        },
-        {
-          name: "Normalize command body",
-          fn: async (_runtime) => {
-            const normalized1 = normalizeCommandBody("/status: test");
-            if (normalized1 !== "/status test") {
-              throw new Error(`Expected '/status test', got '${normalized1}'`);
-            }
-            const normalized2 = normalizeCommandBody("@bot /help", "bot");
-            if (normalized2 !== "/help") {
-              throw new Error(`Expected '/help', got '${normalized2}'`);
-            }
-            import_core.logger.success("Command normalization works correctly");
-          }
-        },
-        {
-          name: "Find command by alias",
-          fn: async (_runtime) => {
-            const cmd = findCommandByAlias("/h");
-            if (!cmd) {
-              throw new Error("Should find help command by /h alias");
-            }
-            if (cmd.key !== "help") {
-              throw new Error(`Expected key 'help', got '${cmd.key}'`);
-            }
-            import_core.logger.success("Command alias lookup works correctly");
-          }
-        },
-        {
-          name: "Find command by key",
-          fn: async (_runtime) => {
-            const cmd = findCommandByKey("status");
-            if (!cmd) {
-              throw new Error("Should find status command by key");
-            }
-            if (cmd.key !== "status") {
-              throw new Error(`Expected key 'status', got '${cmd.key}'`);
-            }
-            import_core.logger.success("Command key lookup works correctly");
-          }
-        }
-      ]
-    },
-    {
-      name: "command-registry",
-      tests: [
-        {
-          name: "Get enabled commands",
-          fn: async (_runtime) => {
-            const commands = getEnabledCommands();
-            if (commands.length === 0) {
-              throw new Error("Should have enabled commands");
-            }
-            const cmdHelp = commands.some((c) => c.key === "help");
-            const cmdStatus = commands.some((c) => c.key === "status");
-            if (!cmdHelp || !cmdStatus) {
-              throw new Error("Should have help and status commands");
-            }
-            import_core.logger.success("Command registry works correctly");
-          }
-        },
-        {
-          name: "Register custom command",
-          fn: async (_runtime) => {
-            const customCmd = {
-              key: "test-custom",
-              description: "Test custom command",
-              textAliases: ["/test-custom", "/tc"],
-              scope: "text"
-            };
-            registerCommand(customCmd);
-            const found = findCommandByKey("test-custom");
-            if (!found) {
-              throw new Error("Should find registered custom command");
-            }
-            unregisterCommand("test-custom");
-            const notFound = findCommandByKey("test-custom");
-            if (notFound) {
-              throw new Error("Should not find unregistered command");
-            }
-            import_core.logger.success("Custom command registration works correctly");
-          }
-        },
-        {
-          name: "Get commands by category",
-          fn: async (_runtime) => {
-            const statusCommands = getCommandsByCategory("status");
-            if (statusCommands.length === 0) {
-              throw new Error("Should have status category commands");
-            }
-            const allStatus = statusCommands.every((c) => c.category === "status");
-            if (!allStatus) {
-              throw new Error("All returned commands should be in status category");
-            }
-            import_core.logger.success("Command categorization works correctly");
-          }
-        }
-      ]
-    }
-  ],
-  async init(config, runtime) {
-    import_core.logger.log("[plugin-commands] Initializing command system");
-    initForRuntime(runtime.agentId);
-    const configEnabled = config.COMMANDS_CONFIG_ENABLED === "true";
-    const debugEnabled = config.COMMANDS_DEBUG_ENABLED === "true";
-    const bashEnabled = config.COMMANDS_BASH_ENABLED === "true";
-    const restartEnabled = config.COMMANDS_RESTART_ENABLED !== "false";
-    const configCmd = findCommandByKey("config");
-    if (configCmd) {
-      configCmd.enabled = configEnabled;
-    }
-    const debugCmd = findCommandByKey("debug");
-    if (debugCmd) {
-      debugCmd.enabled = debugEnabled;
-    }
-    const bashCmd = findCommandByKey("bash");
-    if (bashCmd) {
-      bashCmd.enabled = bashEnabled;
-    }
-    const restartCmd = findCommandByKey("restart");
-    if (restartCmd) {
-      restartCmd.enabled = restartEnabled;
-    }
-    const enabledCount = getEnabledCommands().length;
-    import_core.logger.log(`[plugin-commands] ${enabledCount} commands enabled for agent ${runtime.agentId}`);
-  }
-};
-var src_default = commandsPlugin;
-
-//# debugId=00FC26667A6E870A64756E2164756E21