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

package/dist/cjs/index.cjs

@@ -42,27 +42,60 @@ __export(exports_src, {
   useRuntime: () => useRuntime,
   unregisterCommand: () => unregisterCommand,
   startsWithCommand: () => startsWithCommand,
+  setCommandSetting: () => setCommandSetting,
+  serializeCommand: () => serializeCommand,
+  runCommand: () => runCommand,
+  resolveSettingsSection: () => resolveSettingsSection,
+  resolveConnectorCommandAuth: () => resolveConnectorCommandAuth,
+  resolveCommand: () => resolveCommand,
   resetCommands: () => resetCommands,
   registerCommands: () => registerCommands,
   registerCommand: () => registerCommand,
   parseCommand: () => parseCommand,
   normalizeCommandBody: () => normalizeCommandBody,
+  navigationCommandDefinitions: () => navigationCommandDefinitions,
+  naturalShortcuts: () => naturalShortcuts,
   isElevated: () => isElevated,
+  isDeterministicCommand: () => isDeterministicCommand,
   isCommandOnly: () => isCommandOnly,
   isAuthorized: () => isAuthorized,
   initForRuntime: () => initForRuntime,
   hasCommand: () => hasCommand,
+  getSettingsSections: () => getSettingsSections,
+  getSettingsSectionChoices: () => getSettingsSectionChoices,
+  getEnabledCommandsForRuntime: () => getEnabledCommandsForRuntime,
   getEnabledCommands: () => getEnabledCommands,
+  getConnectorCommands: () => getConnectorCommands,
+  getCommandsForRuntime: () => getCommandsForRuntime,
+  getCommandsByCategoryForRuntime: () => getCommandsByCategoryForRuntime,
   getCommandsByCategory: () => getCommandsByCategory,
   getCommands: () => getCommands,
+  getCommandSettings: () => getCommandSettings,
+  getCatalogCommands: () => getCatalogCommands,
+  gateConnectorCommandByName: () => gateConnectorCommandByName,
+  gateConnectorCommand: () => gateConnectorCommand,
   formatCommandResult: () => formatCommandResult,
+  findCommandByKeyForRuntime: () => findCommandByKeyForRuntime,
   findCommandByKey: () => findCommandByKey,
+  findCommandByAliasForRuntime: () => findCommandByAliasForRuntime,
   findCommandByAlias: () => findCommandByAlias,
   extractCommand: () => extractCommand,
+  explicitCommandShortcuts: () => explicitCommandShortcuts,
+  dispatchCommandMessage: () => dispatchCommandMessage,
   detectCommand: () => detectCommand,
   default: () => src_default,
+  createCommandShortcuts: () => createCommandShortcuts,
+  createCommandActions: () => createCommandActions,
   commandsPlugin: () => commandsPlugin,
-  commandRegistryProvider: () => commandRegistryProvider
+  commandVisibleForView: () => commandVisibleForView,
+  commandVisibleForSurface: () => commandVisibleForSurface,
+  commandShortcuts: () => commandShortcuts,
+  commandRegistryProvider: () => commandRegistryProvider,
+  commandActions: () => commandActions,
+  clearCommandSettings: () => clearCommandSettings,
+  DETERMINISTIC_COMMAND_KEYS: () => DETERMINISTIC_COMMAND_KEYS,
+  DEFAULT_COMMANDS: () => DEFAULT_COMMANDS,
+  COMMAND_SETTING_CHOICES: () => COMMAND_SETTING_CHOICES
 });
 module.exports = __toCommonJS(exports_src);
 var import_core = require("@elizaos/core");
@@ -161,6 +194,7 @@ var DEFAULT_COMMANDS = [
     scope: "both",
     category: "session",
     acceptsArgs: true,
+    requiresAuth: true,
     args: [
       { name: "instructions", description: "Optional compaction instructions" }
     ]
@@ -216,7 +250,13 @@ var DEFAULT_COMMANDS = [
     scope: "both",
     category: "options",
     acceptsArgs: true,
-    args: [{ name: "model", description: "provider/model or alias" }]
+    args: [
+      {
+        name: "model",
+        description: "provider/model or alias",
+        dynamicChoices: "models"
+      }
+    ]
   },
   {
     key: "models",
@@ -331,6 +371,15 @@ var DEFAULT_COMMANDS = [
       }
     ]
   },
+  {
+    key: "transcribe",
+    nativeName: "transcribe",
+    description: "Toggle long-form transcription mode (record-only; agent stays silent until an exit phrase)",
+    textAliases: ["/transcribe", "/transcription", "/dictate"],
+    scope: "both",
+    category: "media",
+    acceptsArgs: false
+  },
   {
     key: "bash",
     nativeName: "bash",
@@ -365,10 +414,7 @@ function initForRuntime(agentId) {
   activeStore = store;
 }
 function useRuntime(agentId) {
-  const store = runtimeStores.get(agentId);
-  if (store) {
-    activeStore = store;
-  }
+  activeStore = storeForRuntime(agentId);
 }
 function getCommands() {
   return [...activeStore.commands];
@@ -427,12 +473,55 @@ function startsWithCommand(text) {
     if (normalized === alias) {
       return command;
     }
-    if (normalized.startsWith(`${alias} `) || normalized.startsWith(`${alias}:`)) {
+    const remainder = normalized.slice(alias.length);
+    if (normalized.startsWith(alias) && /^[\s:]/.test(remainder)) {
       return command;
     }
   }
   return;
 }
+function storeForRuntime(agentId) {
+  if (!agentId)
+    return fallbackStore;
+  return runtimeStores.get(agentId) ?? fallbackStore;
+}
+function getEnabledCommandsFromStore(store) {
+  return store.commands.filter((cmd) => cmd.enabled !== false);
+}
+function getCommandsByCategoryFromStore(store, category) {
+  return store.commands.filter((cmd) => cmd.category === category && cmd.enabled !== false);
+}
+function getAliasMapForStore(store) {
+  if (store.aliasMap)
+    return store.aliasMap;
+  store.aliasMap = new Map;
+  for (const command of store.commands) {
+    if (command.enabled === false)
+      continue;
+    for (const alias of command.textAliases) {
+      const normalized = alias.toLowerCase().trim();
+      if (!store.aliasMap.has(normalized)) {
+        store.aliasMap.set(normalized, command);
+      }
+    }
+  }
+  return store.aliasMap;
+}
+function getCommandsForRuntime(agentId) {
+  return [...storeForRuntime(agentId).commands];
+}
+function getEnabledCommandsForRuntime(agentId) {
+  return getEnabledCommandsFromStore(storeForRuntime(agentId));
+}
+function getCommandsByCategoryForRuntime(category, agentId) {
+  return getCommandsByCategoryFromStore(storeForRuntime(agentId), category);
+}
+function findCommandByAliasForRuntime(alias, agentId) {
+  return getAliasMapForStore(storeForRuntime(agentId)).get(alias.toLowerCase().trim());
+}
+function findCommandByKeyForRuntime(key, agentId) {
+  return storeForRuntime(agentId).commands.find((c) => c.key === key);
+}
 
 // src/parser.ts
 var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -471,7 +560,8 @@ function parseCommand(text, definition) {
       matchedAlias = alias;
       break;
     }
-    if (trimmed.toLowerCase().startsWith(`${normalized} `) || trimmed.toLowerCase().startsWith(`${normalized}:`)) {
+    const remainder = trimmed.slice(alias.length);
+    if (trimmed.toLowerCase().startsWith(normalized) && /^[\s:]/.test(remainder)) {
       matchedAlias = alias;
       break;
     }
@@ -484,12 +574,15 @@ function parseCommand(text, definition) {
     rawArgs = rawArgs.slice(1).trim();
   }
   const args = parseArgs(rawArgs, definition);
-  return {
+  const parsed = {
     key: definition.key,
     canonical: definition.textAliases[0] ?? `/${definition.key}`,
-    args,
-    rawArgs: rawArgs || undefined
+    args
   };
+  if (rawArgs) {
+    parsed.rawArgs = rawArgs;
+  }
+  return parsed;
 }
 function parseArgs(rawArgs, definition) {
   if (!rawArgs || !definition.acceptsArgs) {
@@ -502,13 +595,13 @@ function parseArgs(rawArgs, definition) {
   const args = [];
   const argDefs = definition.args ?? [];
   const tokens = tokenize(rawArgs);
-  for (let i = 0;i < tokens.length; i++) {
+  for (const [i, token] of tokens.entries()) {
     const argDef = argDefs[i];
     if (argDef?.captureRemaining) {
       args.push(tokens.slice(i).join(" "));
       break;
     }
-    args.push(tokens[i]);
+    args.push(token);
   }
   return args;
 }
@@ -517,8 +610,7 @@ function tokenize(input) {
   let current = "";
   let inQuote = false;
   let quoteChar = "";
-  for (let i = 0;i < input.length; i++) {
-    const char = input[i];
+  for (const char of input) {
     if (inQuote) {
       if (char === quoteChar) {
         inQuote = false;
@@ -552,7 +644,7 @@ function normalizeCommandBody(text, botMention) {
     const mentionPattern = new RegExp(`^@${escapeRegExp(botMention)}\\s*`, "i");
     normalized = normalized.replace(mentionPattern, "");
   }
-  normalized = normalized.replace(/^(\/\w+):\s*/, "$1 ");
+  normalized = normalized.replace(/^([/!][^\s:]+):\s*/, "$1 ");
   return normalized.trim();
 }
 function isCommandOnly(text) {
@@ -577,6 +669,849 @@ function extractCommand(text) {
   return { command, remainingText: command.rawArgs };
 }
 
+// src/actions/command-settings.ts
+var COMMAND_SETTING_CHOICES = {
+  thinking: ["off", "minimal", "low", "medium", "high", "xhigh"],
+  verbose: ["off", "on", "full"],
+  reasoning: ["off", "on", "stream"],
+  queue: ["steer", "followup", "collect", "interrupt"],
+  elevated: ["off", "on", "ask", "full"],
+  model: null,
+  tts: ["on", "off"]
+};
+function cacheKey(roomId) {
+  return `command-settings:${roomId}`;
+}
+async function clearCommandSettings(runtime, roomId) {
+  return runtime.deleteCache(cacheKey(roomId));
+}
+async function getCommandSettings(runtime, roomId) {
+  const stored = await runtime.getCache(cacheKey(roomId));
+  return stored ?? {};
+}
+async function setCommandSetting(runtime, roomId, key, rawValue) {
+  const value = rawValue.trim().toLowerCase();
+  const choices = COMMAND_SETTING_CHOICES[key];
+  if (choices && !choices.includes(value)) {
+    return {
+      error: `Invalid ${key} value "${rawValue}". Choose one of: ${choices.join(", ")}.`
+    };
+  }
+  const normalized = choices ? value : rawValue.trim();
+  const current = await getCommandSettings(runtime, roomId);
+  await runtime.setCache(cacheKey(roomId), {
+    ...current,
+    [key]: normalized
+  });
+  return { value: normalized };
+}
+
+// src/actions/handlers.ts
+var DETERMINISTIC_COMMAND_KEYS = [
+  "help",
+  "commands",
+  "status",
+  "whoami",
+  "context",
+  "reset",
+  "new",
+  "compact",
+  "models",
+  "usage",
+  "think",
+  "verbose",
+  "reasoning",
+  "queue",
+  "elevated",
+  "model",
+  "tts"
+];
+var DETERMINISTIC_KEYS = new Set(DETERMINISTIC_COMMAND_KEYS);
+function isDeterministicCommand(key) {
+  return DETERMINISTIC_KEYS.has(key);
+}
+var CATEGORY_ORDER = [
+  "status",
+  "session",
+  "options",
+  "media",
+  "management",
+  "tools",
+  "docks",
+  "skills"
+];
+var OPTION_COMMANDS = {
+  think: { key: "thinking", label: "Thinking" },
+  verbose: { key: "verbose", label: "Verbose" },
+  reasoning: { key: "reasoning", label: "Reasoning" },
+  queue: { key: "queue", label: "Queue mode" },
+  elevated: { key: "elevated", label: "Elevated mode" },
+  model: { key: "model", label: "Model" },
+  tts: { key: "tts", label: "TTS" }
+};
+function reply(text) {
+  return { handled: true, reply: text, shouldContinue: false };
+}
+function authError() {
+  return reply("This command requires authorization.");
+}
+function formatCommandList(agentId) {
+  const lines = [];
+  for (const category of CATEGORY_ORDER) {
+    const commands = getCommandsByCategoryForRuntime(category, agentId);
+    if (commands.length === 0)
+      continue;
+    lines.push(`**${category}**`);
+    for (const command of commands) {
+      const alias = command.textAliases[0] ?? `/${command.key}`;
+      const auth = command.requiresAuth ? " (requires auth)" : "";
+      lines.push(`  ${alias} — ${command.description}${auth}`);
+    }
+  }
+  return lines.join(`
+`);
+}
+function resolveModelLabel(runtime) {
+  const fromSetting = runtime.getSetting("LARGE_MODEL") ?? runtime.getSetting("ANTHROPIC_LARGE_MODEL") ?? runtime.getSetting("OPENAI_LARGE_MODEL");
+  if (typeof fromSetting === "string" && fromSetting.trim()) {
+    return fromSetting.trim();
+  }
+  const fromCharacter = runtime.character?.settings?.model;
+  if (typeof fromCharacter === "string" && fromCharacter.trim()) {
+    return fromCharacter.trim();
+  }
+  return "default";
+}
+async function countRoomMessages(runtime, roomId) {
+  if (typeof runtime.countMemories !== "function")
+    return null;
+  try {
+    return await runtime.countMemories({
+      roomIds: [roomId],
+      tableName: "messages",
+      unique: false
+    });
+  } catch {
+    return null;
+  }
+}
+async function clearRoomMessages(runtime, roomId) {
+  const before = await countRoomMessages(runtime, roomId);
+  if (typeof runtime.deleteAllMemories !== "function")
+    return null;
+  await runtime.deleteAllMemories([roomId], "messages");
+  return before;
+}
+function findAction(runtime, name) {
+  return runtime.actions?.find((action) => action.name === name);
+}
+async function runCompactAction(runtime, message, callback) {
+  const action = findAction(runtime, "COMPACT_CONVERSATION");
+  if (!action || !message) {
+    return reply("Conversation compaction is not available in this runtime.");
+  }
+  const result = await action.handler(runtime, message, undefined, undefined, callback);
+  if (result?.text && result.text.trim().length > 0)
+    return reply(result.text);
+  return reply("Conversation compaction completed.");
+}
+async function setOptionCommand(runtime, roomId, parsed, option) {
+  const rawValue = parsed.rawArgs?.trim() ?? parsed.args[0]?.trim() ?? "";
+  if (!rawValue) {
+    const settings = await getCommandSettings(runtime, roomId);
+    const current = option.key === "model" ? settings.model ?? resolveModelLabel(runtime) : settings[option.key] ?? "default";
+    return reply(`${option.label} is ${current}.`);
+  }
+  const result = await setCommandSetting(runtime, roomId, option.key, rawValue);
+  if ("error" in result)
+    return reply(result.error);
+  return reply(`${option.label} set to ${result.value}.`);
+}
+async function runCommand(runtime, parsed, context) {
+  const agentId = runtime.agentId;
+  useRuntime(agentId);
+  const definition = findCommandByKeyForRuntime(parsed.key, agentId);
+  if (definition?.requiresAuth && !context.isAuthorized)
+    return authError();
+  if (definition?.requiresElevated && !context.isElevated) {
+    return reply("This command requires elevated permissions.");
+  }
+  const roomId = context.roomId;
+  switch (parsed.key) {
+    case "help":
+    case "commands":
+      return reply(`Available commands:
+${formatCommandList(agentId)}`);
+    case "status": {
+      const settings = await getCommandSettings(runtime, roomId);
+      const messageCount = await countRoomMessages(runtime, roomId);
+      const lines = [
+        `Agent: ${runtime.character?.name ?? runtime.agentId}`,
+        `Model: ${settings.model ?? resolveModelLabel(runtime)}`,
+        `Thinking: ${settings.thinking ?? "default"}`,
+        `Reasoning: ${settings.reasoning ?? "default"}`,
+        `Verbose: ${settings.verbose ?? "default"}`,
+        `Queue: ${settings.queue ?? "default"}`,
+        `TTS: ${settings.tts ?? "default"}`,
+        messageCount === null ? null : `Messages: ${messageCount}`,
+        `Commands enabled: ${getEnabledCommandsForRuntime(agentId).length}`
+      ].filter(Boolean);
+      return reply(lines.join(`
+`));
+    }
+    case "whoami": {
+      const who = context.senderName ?? context.senderId ?? "you";
+      return reply(`You are ${who}.
+Authorized: ${context.isAuthorized ? "yes" : "no"}
+Elevated: ${context.isElevated ? "yes" : "no"}`);
+    }
+    case "context": {
+      const settings = await getCommandSettings(runtime, roomId);
+      const lines = [
+        `Room: ${roomId}`,
+        context.channelId ? `Channel: ${context.channelId}` : null,
+        `Active settings: ${describeSettings(settings)}`
+      ].filter(Boolean);
+      return reply(lines.join(`
+`));
+    }
+    case "models":
+      return reply(`Current model: ${resolveModelLabel(runtime)}`);
+    case "usage": {
+      const usage = await runtime.getCache(`token-usage:${roomId}`);
+      if (!usage?.totalTokens) {
+        return reply("No token usage recorded for this conversation yet.");
+      }
+      return reply(`Token usage — prompt: ${usage.promptTokens ?? 0}, completion: ${usage.completionTokens ?? 0}, total: ${usage.totalTokens}.`);
+    }
+    case "think":
+    case "verbose":
+    case "reasoning":
+    case "queue":
+    case "elevated":
+    case "model":
+    case "tts":
+      return setOptionCommand(runtime, roomId, parsed, OPTION_COMMANDS[parsed.key]);
+    case "reset": {
+      await clearCommandSettings(runtime, roomId);
+      const deleted = await clearRoomMessages(runtime, roomId);
+      if (deleted === null) {
+        return reply("Reset command settings for this room. Message history is unchanged because memory deletion is unavailable.");
+      }
+      return reply(`Reset this room: cleared command settings and ${deleted} message(s).`);
+    }
+    case "new":
+      await clearCommandSettings(runtime, roomId);
+      return reply("Started a new conversation context for this room.");
+    case "compact":
+      return runCompactAction(runtime, context.message, context.callback);
+    default:
+      return { handled: false, shouldContinue: true };
+  }
+}
+function describeSettings(settings) {
+  const entries = Object.entries(settings).filter(([, v]) => v);
+  if (entries.length === 0)
+    return "none";
+  return entries.map(([k, v]) => `${k}=${v}`).join(", ");
+}
+
+// src/actions/dispatch.ts
+function buildContext(message, options) {
+  const content = message.content;
+  const context = {
+    senderId: message.entityId,
+    isAuthorized: options.isAuthorized ?? false,
+    isElevated: options.isElevated ?? false,
+    roomId: message.roomId,
+    message
+  };
+  if (options.senderName)
+    context.senderName = options.senderName;
+  if (options.callback)
+    context.callback = options.callback;
+  const channelId = content.channelId ?? content.source;
+  if (channelId)
+    context.channelId = channelId;
+  return context;
+}
+async function resolveCommand(runtime, message, options = {}) {
+  const text = message.content.text ?? "";
+  if (!hasCommand(text))
+    return { handled: false };
+  const detection = detectCommand(text);
+  if (!detection.isCommand || !detection.command)
+    return { handled: false };
+  const parsed = detection.command;
+  const definition = findCommandByKeyForRuntime(parsed.key, runtime.agentId);
+  if (definition?.target && definition.target.kind !== "agent") {
+    return { handled: false, command: parsed };
+  }
+  const deterministicOnly = options.deterministicOnly ?? options.gateSafeOnly ?? true;
+  if (deterministicOnly && !isDeterministicCommand(parsed.key)) {
+    return { handled: false, command: parsed };
+  }
+  const result = await runCommand(runtime, parsed, buildContext(message, options));
+  if (!result.handled)
+    return { handled: false, command: parsed };
+  const dispatched = { handled: true, command: parsed };
+  if (result.reply !== undefined)
+    dispatched.reply = result.reply;
+  return dispatched;
+}
+async function dispatchCommandMessage(runtime, message, callback, options = {}) {
+  const result = await resolveCommand(runtime, message, options);
+  if (!result.handled || result.reply === undefined)
+    return false;
+  await callback({ text: result.reply, source: "command" });
+  return true;
+}
+
+// src/actions/command-actions.ts
+var OWNER_SOURCES = new Set([
+  "client_chat",
+  "gui",
+  "tui",
+  "direct",
+  "dashboard"
+]);
+function resolveTrust(message) {
+  const source = message.content.source;
+  const trusted = !source || OWNER_SOURCES.has(source);
+  return { isAuthorized: trusted, isElevated: trusted };
+}
+function buildAction(key, _nativeName, description, aliases) {
+  return {
+    name: `${key.toUpperCase()}_COMMAND`,
+    description,
+    similes: aliases,
+    suppressEarlyReply: true,
+    suppressPostActionContinuation: true,
+    validate: async (_runtime, message) => {
+      const text = message.content.text ?? "";
+      if (!hasCommand(text))
+        return false;
+      const detection = detectCommand(text);
+      return detection.isCommand && detection.command?.key === key;
+    },
+    handler: async (runtime, message, _state, _options, callback) => {
+      const result = await resolveCommand(runtime, message, {
+        ...resolveTrust(message),
+        deterministicOnly: true,
+        ...callback ? { callback } : {}
+      });
+      if (!result.handled || result.reply === undefined) {
+        return { success: false };
+      }
+      if (callback) {
+        await callback({ text: result.reply, source: "command" });
+      }
+      return { success: true, text: result.reply };
+    }
+  };
+}
+function createCommandActions(commandKeys) {
+  const actions = [];
+  for (const key of commandKeys) {
+    if (!isDeterministicCommand(key))
+      continue;
+    const definition = findCommandByKey(key);
+    if (!definition)
+      continue;
+    if (definition.target && definition.target.kind !== "agent")
+      continue;
+    actions.push(buildAction(key, definition.nativeName ?? key, definition.description, definition.textAliases));
+  }
+  return actions;
+}
+// src/actions/shortcuts.ts
+function createCommandShortcuts(commandKeys = DETERMINISTIC_COMMAND_KEYS) {
+  const shortcuts = [];
+  for (const key of commandKeys) {
+    const definition = findCommandByKey(key);
+    if (!definition)
+      continue;
+    if (definition.target && definition.target.kind !== "agent")
+      continue;
+    shortcuts.push({
+      id: `cmd:${key}`,
+      kind: "explicit",
+      aliases: definition.textAliases,
+      target: { kind: "action", name: `${key.toUpperCase()}_COMMAND` }
+    });
+  }
+  return shortcuts;
+}
+var explicitCommandShortcuts = createCommandShortcuts();
+var naturalShortcuts = [
+  {
+    id: "nl:commands",
+    kind: "natural",
+    patterns: [
+      {
+        regex: /^what commands (?:can i (?:use|run)|are (?:there|available)|do you (?:have|support))$/u
+      },
+      {
+        regex: /^(?:show|list|give|tell)(?: me)?(?: a list of| the list of| all(?: of)?| the| your| available)* commands$/u
+      },
+      { regex: /^what are(?: all)?(?: the| your| available)* commands$/u }
+    ],
+    target: { kind: "action", name: "COMMANDS_COMMAND" },
+    requiresAction: "COMMANDS_COMMAND",
+    confidence: 0.95
+  }
+];
+var commandShortcuts = [
+  ...explicitCommandShortcuts,
+  ...naturalShortcuts
+];
+
+// src/actions/index.ts
+var commandActions = createCommandActions([
+  ...DETERMINISTIC_COMMAND_KEYS
+]);
+// src/connector-bridge.ts
+function resolveConnectorCommandAuth(agentId, name) {
+  const definition = findCommandByKeyForRuntime(name, agentId);
+  return {
+    requiresAuth: definition?.requiresAuth ?? false,
+    requiresElevated: definition?.requiresElevated ?? false
+  };
+}
+function gateConnectorCommand(requirements, sender) {
+  if (requirements.requiresAuth && !sender.isAuthorized) {
+    return {
+      allowed: false,
+      reply: "This command requires authorization. Pair your account or ask an owner to run it."
+    };
+  }
+  if (requirements.requiresElevated && !sender.isElevated) {
+    return {
+      allowed: false,
+      reply: "This command requires elevated permissions."
+    };
+  }
+  return { allowed: true };
+}
+function gateConnectorCommandByName(agentId, name, sender) {
+  return gateConnectorCommand(resolveConnectorCommandAuth(agentId, name), sender);
+}
+// src/settings-sections.ts
+var SETTINGS_SECTIONS = [
+  {
+    id: "ai-model",
+    label: "AI Model & Providers",
+    aliases: ["model", "models", "providers", "provider", "llm"]
+  },
+  { id: "general", label: "General", aliases: ["basics"] },
+  { id: "agent", label: "Agent", aliases: ["character", "persona"] },
+  { id: "voice", label: "Voice", aliases: ["audio", "tts", "speech"] },
+  { id: "connectors", label: "Connectors", aliases: ["integrations"] },
+  { id: "skills", label: "Skills" },
+  { id: "memory", label: "Memory", aliases: ["knowledge"] },
+  { id: "permissions", label: "Permissions", aliases: ["security", "access"] },
+  { id: "billing", label: "Billing", aliases: ["plan", "subscription"] },
+  { id: "appearance", label: "Appearance", aliases: ["theme", "display"] },
+  { id: "notifications", label: "Notifications", aliases: ["alerts"] },
+  { id: "advanced", label: "Advanced", aliases: ["developer", "debug"] }
+];
+var lookup = null;
+function getLookup() {
+  if (lookup)
+    return lookup;
+  const map = new Map;
+  for (const section of SETTINGS_SECTIONS) {
+    map.set(section.id, section);
+    for (const alias of section.aliases ?? []) {
+      map.set(alias, section);
+    }
+  }
+  lookup = map;
+  return map;
+}
+function getSettingsSections() {
+  return [...SETTINGS_SECTIONS];
+}
+function getSettingsSectionChoices() {
+  return SETTINGS_SECTIONS.map((section) => section.id);
+}
+function resolveSettingsSection(raw) {
+  const normalized = raw.trim().toLowerCase();
+  if (!normalized)
+    return;
+  return getLookup().get(normalized)?.id;
+}
+
+// src/navigation-commands.ts
+var IN_APP_SURFACES = ["gui", "tui"];
+var NAVIGATE_COMMANDS = [
+  {
+    key: "settings",
+    nativeName: "settings",
+    description: "Open agent settings",
+    textAliases: ["/settings"],
+    scope: "both",
+    category: "docks",
+    icon: "settings",
+    target: { kind: "navigate", path: "/settings", tab: "settings" },
+    acceptsArgs: true,
+    args: [
+      {
+        name: "section",
+        description: "Settings section to open",
+        required: false,
+        choices: getSettingsSectionChoices(),
+        dynamicChoices: "settings-sections"
+      }
+    ]
+  },
+  {
+    key: "chat",
+    nativeName: "chat",
+    description: "Return to the chat",
+    textAliases: ["/chat"],
+    scope: "both",
+    category: "docks",
+    icon: "message-circle",
+    target: { kind: "navigate", path: "/chat", tab: "chat" }
+  },
+  {
+    key: "views",
+    nativeName: "views",
+    description: "Open the agent's views",
+    textAliases: ["/views"],
+    scope: "both",
+    category: "docks",
+    icon: "layout-grid",
+    target: { kind: "navigate", path: "/views", tab: "views" },
+    acceptsArgs: true,
+    args: [
+      {
+        name: "view",
+        description: "View to open",
+        required: false,
+        dynamicChoices: "views"
+      }
+    ]
+  },
+  {
+    key: "orchestrator",
+    nativeName: "orchestrator",
+    description: "Open the agent orchestrator",
+    textAliases: ["/orchestrator"],
+    scope: "both",
+    category: "docks",
+    icon: "workflow",
+    target: { kind: "navigate", path: "/orchestrator", viewId: "orchestrator" }
+  },
+  {
+    key: "character",
+    nativeName: "character",
+    description: "Open the character editor",
+    textAliases: ["/character"],
+    scope: "both",
+    category: "docks",
+    icon: "user",
+    target: { kind: "navigate", path: "/character", tab: "character" }
+  },
+  {
+    key: "knowledge",
+    nativeName: "knowledge",
+    description: "Open the knowledge base",
+    textAliases: ["/knowledge"],
+    scope: "both",
+    category: "docks",
+    icon: "book-open",
+    target: {
+      kind: "navigate",
+      path: "/character/documents",
+      tab: "documents"
+    }
+  },
+  {
+    key: "wallet",
+    nativeName: "wallet",
+    description: "Open the wallet & inventory",
+    textAliases: ["/wallet"],
+    scope: "both",
+    category: "docks",
+    icon: "wallet",
+    target: { kind: "navigate", path: "/wallet", tab: "inventory" }
+  },
+  {
+    key: "automations",
+    nativeName: "automations",
+    description: "Open automations",
+    textAliases: ["/automations"],
+    scope: "both",
+    category: "docks",
+    icon: "zap",
+    target: { kind: "navigate", path: "/automations", tab: "automations" }
+  },
+  {
+    key: "tasks",
+    nativeName: "tasks",
+    description: "Open tasks",
+    textAliases: ["/tasks"],
+    scope: "both",
+    category: "docks",
+    icon: "check-square",
+    target: { kind: "navigate", path: "/apps/tasks", tab: "tasks" }
+  },
+  {
+    key: "skills",
+    nativeName: "skills",
+    description: "Open the skills library",
+    textAliases: ["/skills"],
+    scope: "both",
+    category: "docks",
+    icon: "sparkles",
+    target: { kind: "navigate", path: "/apps/skills", tab: "skills" }
+  },
+  {
+    key: "plugins",
+    nativeName: "plugins",
+    description: "Open installed plugins",
+    textAliases: ["/plugins"],
+    scope: "both",
+    category: "docks",
+    icon: "plug",
+    target: { kind: "navigate", path: "/apps/plugins", tab: "plugins" }
+  },
+  {
+    key: "logs",
+    nativeName: "logs",
+    description: "Open the logs",
+    textAliases: ["/logs"],
+    scope: "both",
+    category: "docks",
+    icon: "scroll-text",
+    target: { kind: "navigate", path: "/apps/logs", tab: "logs" }
+  },
+  {
+    key: "database",
+    nativeName: "database",
+    description: "Open the database browser",
+    textAliases: ["/database"],
+    scope: "both",
+    category: "docks",
+    icon: "database",
+    target: { kind: "navigate", path: "/apps/database", tab: "database" }
+  }
+];
+var CLIENT_COMMANDS = [
+  {
+    key: "clear",
+    nativeName: "clear",
+    description: "Clear the current chat",
+    textAliases: ["/clear"],
+    scope: "both",
+    category: "docks",
+    icon: "eraser",
+    surfaces: IN_APP_SURFACES,
+    target: { kind: "client", clientAction: "clear-chat" }
+  },
+  {
+    key: "fullscreen",
+    nativeName: "fullscreen",
+    description: "Toggle full-screen chat",
+    textAliases: ["/fullscreen"],
+    scope: "both",
+    category: "docks",
+    icon: "maximize",
+    surfaces: IN_APP_SURFACES,
+    target: { kind: "client", clientAction: "toggle-fullscreen" }
+  },
+  {
+    key: "transcribe",
+    nativeName: "transcribe",
+    description: "Toggle long-form transcription mode (record-only; agent stays silent until an exit phrase)",
+    textAliases: ["/transcribe"],
+    scope: "both",
+    category: "docks",
+    icon: "mic",
+    surfaces: IN_APP_SURFACES,
+    target: { kind: "client", clientAction: "toggle-transcription" }
+  }
+];
+var VIEW_SCOPED_COMMANDS = [
+  {
+    key: "calendar-add",
+    nativeName: "calendar-add",
+    description: "Add a calendar event (in the calendar view)",
+    textAliases: ["/calendar-add"],
+    scope: "both",
+    category: "docks",
+    icon: "calendar-plus",
+    surfaces: IN_APP_SURFACES,
+    views: ["calendar"],
+    target: { kind: "agent" },
+    acceptsArgs: true,
+    args: [{ name: "event", description: "What to schedule", required: false }]
+  },
+  {
+    key: "todos-add",
+    nativeName: "todos-add",
+    description: "Add a to-do (in the todos view)",
+    textAliases: ["/todos-add"],
+    scope: "both",
+    category: "docks",
+    icon: "list-plus",
+    surfaces: IN_APP_SURFACES,
+    views: ["todos"],
+    target: { kind: "agent" },
+    acceptsArgs: true,
+    args: [{ name: "task", description: "What to do", required: false }]
+  },
+  {
+    key: "todos-done",
+    nativeName: "todos-done",
+    description: "Complete a to-do (in the todos view)",
+    textAliases: ["/todos-done"],
+    scope: "both",
+    category: "docks",
+    icon: "check",
+    surfaces: IN_APP_SURFACES,
+    views: ["todos"],
+    target: { kind: "agent" },
+    acceptsArgs: true,
+    args: [
+      { name: "task", description: "Which to-do to complete", required: false }
+    ]
+  },
+  {
+    key: "documents-search",
+    nativeName: "documents-search",
+    description: "Search the knowledge base (in the documents view)",
+    textAliases: ["/documents-search"],
+    scope: "both",
+    category: "docks",
+    icon: "search",
+    surfaces: IN_APP_SURFACES,
+    views: ["documents"],
+    target: { kind: "agent" },
+    acceptsArgs: true,
+    args: [
+      { name: "query", description: "What to search for", required: false }
+    ]
+  }
+];
+function navigationCommandDefinitions() {
+  return [...NAVIGATE_COMMANDS, ...CLIENT_COMMANDS, ...VIEW_SCOPED_COMMANDS];
+}
+
+// src/serialize.ts
+var DEFAULT_TARGET = { kind: "agent" };
+function commandVisibleForSurface(surfaces, surface) {
+  if (!surface)
+    return true;
+  if (!surfaces || surfaces.length === 0)
+    return true;
+  return surfaces.includes(surface);
+}
+function serializeArg(arg) {
+  const serialized = {
+    name: arg.name,
+    description: arg.description
+  };
+  if (arg.required)
+    serialized.required = true;
+  if (arg.captureRemaining)
+    serialized.captureRemaining = true;
+  if (arg.dynamicChoices)
+    serialized.dynamicChoices = arg.dynamicChoices;
+  if (Array.isArray(arg.choices) && arg.choices.length > 0) {
+    serialized.choices = arg.choices;
+  }
+  return serialized;
+}
+function serializeCommand(command, options = {}) {
+  const args = (command.args ?? []).map(serializeArg);
+  const serialized = {
+    key: command.key,
+    nativeName: command.nativeName ?? command.key,
+    description: command.description,
+    textAliases: command.textAliases,
+    scope: command.scope,
+    acceptsArgs: command.acceptsArgs ?? args.length > 0,
+    args,
+    requiresAuth: command.requiresAuth ?? false,
+    requiresElevated: command.requiresElevated ?? false,
+    target: command.target ?? DEFAULT_TARGET,
+    source: options.source ?? "builtin"
+  };
+  if (command.category)
+    serialized.category = command.category;
+  if (command.surfaces && command.surfaces.length > 0) {
+    serialized.surfaces = command.surfaces;
+  }
+  if (command.icon)
+    serialized.icon = command.icon;
+  if (command.views && command.views.length > 0) {
+    serialized.views = command.views;
+  }
+  return serialized;
+}
+
+// src/connector-catalog.ts
+var KNOWN_SURFACES = new Set([
+  "gui",
+  "tui",
+  "discord",
+  "telegram"
+]);
+function commandVisibleForView(views, activeViewId) {
+  if (!views || views.length === 0)
+    return true;
+  if (!activeViewId)
+    return false;
+  return views.includes(activeViewId);
+}
+function isConnectorScoped(command) {
+  return command.scope !== "text";
+}
+function commandName(command) {
+  return command.nativeName ?? command.key;
+}
+function unifiedDefinitions(agentId) {
+  const agentCommands = agentId ? getEnabledCommandsForRuntime(agentId) : DEFAULT_COMMANDS.filter((command) => command.enabled !== false);
+  const agent = agentCommands.filter(isConnectorScoped);
+  const navigation = navigationCommandDefinitions();
+  const navigationNames = new Set(navigation.map(commandName));
+  const agentOnly = agent.filter((command) => !navigationNames.has(commandName(command)));
+  return [...agentOnly, ...navigation];
+}
+function normalizeSurface(surface) {
+  return KNOWN_SURFACES.has(surface) ? surface : null;
+}
+function visibleDefinitions(surface, activeViewId, agentId) {
+  const normalized = normalizeSurface(surface);
+  return unifiedDefinitions(agentId).filter((command) => commandVisibleForSurface(command.surfaces, normalized)).filter((command) => commandVisibleForView(command.views, activeViewId));
+}
+function mapDefinitionArg(arg) {
+  return {
+    name: arg.name,
+    description: arg.description,
+    required: arg.required ?? false,
+    choices: Array.isArray(arg.choices) ? arg.choices : []
+  };
+}
+function toConnectorCommand(command) {
+  return {
+    name: commandName(command),
+    description: command.description,
+    target: command.target ?? { kind: "agent" },
+    options: (command.args ?? []).map(mapDefinitionArg),
+    ...command.views && command.views.length > 0 ? { views: command.views } : {}
+  };
+}
+function getConnectorCommands(surface, options = {}) {
+  return visibleDefinitions(surface, options.activeViewId, options.agentId).map(toConnectorCommand);
+}
+function getCatalogCommands(surface, options = {}) {
+  return visibleDefinitions(surface, options.activeViewId, options.agentId).map((command) => serializeCommand(command, options.source ? { source: options.source } : {}));
+}
+
 // src/index.ts
 var commandRegistryProvider = {
   name: "COMMAND_REGISTRY",
@@ -588,10 +1523,9 @@ var commandRegistryProvider = {
   cacheStable: true,
   cacheScope: "agent",
   async get(runtime, message, _state) {
-    useRuntime(runtime.agentId);
-    const text = message.content?.text ?? "";
+    const text = message.content.text ?? "";
     const isCommand = hasCommand(text);
-    const commands = getEnabledCommands();
+    const commands = getEnabledCommandsForRuntime(runtime.agentId);
     if (isCommand) {
       const commandList = commands.map((cmd) => {
         const auth = cmd.requiresAuth ? " (requires auth)" : "";
@@ -643,14 +1577,15 @@ var commandsPlugin = {
   name: "commands",
   description: "Chat command system with /help, /status, /reset, etc.",
   providers: [commandRegistryProvider],
+  actions: commandActions,
+  shortcuts: commandShortcuts,
   autoEnable: {
     shouldEnable: (_env, config) => {
-      const f = config?.features?.commands;
+      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",
@@ -685,8 +1620,8 @@ var commandsPlugin = {
             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]}'`);
+            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");
           }
@@ -819,4 +1754,4 @@ var commandsPlugin = {
 };
 var src_default = commandsPlugin;
 
-//# debugId=00FC26667A6E870A64756E2164756E21
+//# debugId=D816A7531DE8F68364756E2164756E21