@gakr-gakr/discord 0.1.0

package/src/monitor/native-command-ui.ts

@@ -0,0 +1,26 @@
+export {
+  buildDiscordCommandArgCustomId,
+  buildDiscordCommandArgMenu,
+  createDiscordCommandArgFallbackButton,
+  handleDiscordCommandArgInteraction,
+} from "./native-command-arg-ui.js";
+export {
+  createDiscordModelPickerFallbackButton,
+  createDiscordModelPickerFallbackSelect,
+  handleDiscordModelPickerInteraction,
+} from "./native-command-model-picker-interaction.js";
+export {
+  replyWithDiscordModelPickerProviders,
+  resolveDiscordNativeChoiceContext,
+  shouldOpenDiscordModelPickerFromCommand,
+} from "./native-command-model-picker-ui.js";
+export type {
+  DispatchDiscordCommandInteraction,
+  DispatchDiscordCommandInteractionParams,
+  DispatchDiscordCommandInteractionResult,
+} from "./native-command-dispatch.js";
+export type {
+  DiscordCommandArgContext,
+  DiscordModelPickerContext,
+  SafeDiscordInteractionCall,
+} from "./native-command-ui.types.js";

package/src/monitor/native-command-ui.types.ts

@@ -0,0 +1,20 @@
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import type { ThreadBindingManager } from "./thread-bindings.js";
+
+type DiscordConfig = NonNullable<AutoBotConfig["channels"]>["discord"];
+
+export type DiscordCommandArgContext = {
+  cfg: AutoBotConfig;
+  discordConfig: DiscordConfig;
+  accountId: string;
+  sessionPrefix: string;
+  threadBindings: ThreadBindingManager;
+  postApplySettleMs?: number;
+};
+
+export type DiscordModelPickerContext = DiscordCommandArgContext;
+
+export type SafeDiscordInteractionCall = <T>(
+  label: string,
+  fn: () => Promise<T>,
+) => Promise<T | null>;

package/src/monitor/native-command.args.ts

@@ -0,0 +1,45 @@
+import {
+  type ChatCommandDefinition,
+  type CommandArgDefinition,
+  type CommandArgValues,
+  type NativeCommandSpec,
+} from "autobot/plugin-sdk/native-command-registry";
+import type { CommandInteraction } from "../internal/discord.js";
+import type { DiscordCommandArgs } from "./native-command.types.js";
+
+export function readDiscordCommandArgs(
+  interaction: CommandInteraction,
+  definitions?: CommandArgDefinition[],
+): DiscordCommandArgs | undefined {
+  if (!definitions || definitions.length === 0) {
+    return undefined;
+  }
+  const values: CommandArgValues = {};
+  for (const definition of definitions) {
+    let value: string | number | boolean | null | undefined;
+    if (definition.type === "number") {
+      value = interaction.options.getNumber(definition.name) ?? null;
+    } else if (definition.type === "boolean") {
+      value = interaction.options.getBoolean(definition.name) ?? null;
+    } else {
+      value = interaction.options.getString(definition.name) ?? null;
+    }
+    if (value != null) {
+      values[definition.name] = value;
+    }
+  }
+  return Object.keys(values).length > 0 ? { values } : undefined;
+}
+
+export function createNativeCommandDefinition(command: NativeCommandSpec): ChatCommandDefinition {
+  return {
+    key: command.name,
+    nativeName: command.name,
+    description: command.description,
+    textAliases: [],
+    acceptsArgs: command.acceptsArgs,
+    args: command.args,
+    argsParsing: "none",
+    scope: "native",
+  };
+}

package/src/monitor/native-command.options.ts

@@ -0,0 +1,153 @@
+import { ApplicationCommandOptionType } from "discord-api-types/v10";
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import {
+  resolveCommandArgChoices,
+  type ChatCommandDefinition,
+} from "autobot/plugin-sdk/native-command-registry";
+import { createSubsystemLogger } from "autobot/plugin-sdk/runtime-env";
+import { normalizeLowercaseStringOrEmpty } from "autobot/plugin-sdk/string-coerce-runtime";
+import type { AutocompleteInteraction, CommandOptions } from "../internal/discord.js";
+
+const log = createSubsystemLogger("discord/native-command");
+
+// Discord application command and option descriptions are limited to 1-100 chars.
+// https://discord.com/developers/docs/interactions/application-commands#application-command-object-application-command-structure
+const DISCORD_COMMAND_DESCRIPTION_MAX = 100;
+
+export function truncateDiscordCommandDescription(params: {
+  value: string;
+  label: string;
+}): string {
+  const { value, label } = params;
+  if (value.length <= DISCORD_COMMAND_DESCRIPTION_MAX) {
+    return value;
+  }
+  log.warn(
+    `discord: truncating native command description (${label}) from ${value.length} to ${DISCORD_COMMAND_DESCRIPTION_MAX}: ${JSON.stringify(value)}`,
+  );
+  return value.slice(0, DISCORD_COMMAND_DESCRIPTION_MAX);
+}
+
+export function truncateDiscordCommandDescriptionLocalizations(params: {
+  value?: Record<string, string>;
+  label: string;
+}): Record<string, string> | undefined {
+  const entries = Object.entries(params.value ?? {});
+  if (entries.length === 0) {
+    return undefined;
+  }
+  return Object.fromEntries(
+    entries.map(([locale, description]) => [
+      locale,
+      truncateDiscordCommandDescription({
+        value: description,
+        label: `${params.label} locale:${locale}`,
+      }),
+    ]),
+  );
+}
+
+function resolveDiscordCommandLogLabel(command: ChatCommandDefinition): string {
+  if (typeof command.nativeName === "string" && command.nativeName.trim().length > 0) {
+    return command.nativeName;
+  }
+  return command.key;
+}
+
+export function buildDiscordCommandOptions(params: {
+  command: ChatCommandDefinition;
+  cfg: AutoBotConfig;
+  authorizeChoiceContext?: (interaction: AutocompleteInteraction) => Promise<boolean>;
+  resolveChoiceContext?: (
+    interaction: AutocompleteInteraction,
+  ) => Promise<{ provider?: string; model?: string } | null>;
+}): CommandOptions | undefined {
+  const { command, cfg, authorizeChoiceContext, resolveChoiceContext } = params;
+  const commandLabel = resolveDiscordCommandLogLabel(command);
+  const args = command.args;
+  if (!args || args.length === 0) {
+    return undefined;
+  }
+  return args.map((arg) => {
+    const required = arg.required ?? false;
+    if (arg.type === "number") {
+      return {
+        name: arg.name,
+        description: truncateDiscordCommandDescription({
+          value: arg.description,
+          label: `command:${commandLabel} arg:${arg.name}`,
+        }),
+        type: ApplicationCommandOptionType.Number,
+        required,
+      };
+    }
+    if (arg.type === "boolean") {
+      return {
+        name: arg.name,
+        description: truncateDiscordCommandDescription({
+          value: arg.description,
+          label: `command:${commandLabel} arg:${arg.name}`,
+        }),
+        type: ApplicationCommandOptionType.Boolean,
+        required,
+      };
+    }
+    const resolvedChoices = resolveCommandArgChoices({ command, arg, cfg });
+    const shouldAutocomplete =
+      arg.preferAutocomplete === true ||
+      (resolvedChoices.length > 0 &&
+        (typeof arg.choices === "function" || resolvedChoices.length > 25));
+    const autocomplete = shouldAutocomplete
+      ? async (interaction: AutocompleteInteraction) => {
+          if (
+            typeof arg.choices === "function" &&
+            resolveChoiceContext &&
+            authorizeChoiceContext &&
+            !(await authorizeChoiceContext(interaction))
+          ) {
+            await interaction.respond([]);
+            return;
+          }
+          const focused = interaction.options.getFocused();
+          const focusValue = normalizeLowercaseStringOrEmpty(focused?.value);
+          const context =
+            typeof arg.choices === "function" && resolveChoiceContext
+              ? await resolveChoiceContext(interaction)
+              : null;
+          const choices = resolveCommandArgChoices({
+            command,
+            arg,
+            cfg,
+            provider: context?.provider,
+            model: context?.model,
+          });
+          const filtered = focusValue
+            ? choices.filter((choice) =>
+                normalizeLowercaseStringOrEmpty(choice.label).includes(focusValue),
+              )
+            : choices;
+          await interaction.respond(
+            filtered.slice(0, 25).map((choice) => ({ name: choice.label, value: choice.value })),
+          );
+        }
+      : undefined;
+    const choices =
+      resolvedChoices.length > 0 && !autocomplete
+        ? resolvedChoices.slice(0, 25).map((choice) => ({
+            name: choice.label,
+            value: choice.value,
+          }))
+        : undefined;
+    return {
+      name: arg.name,
+      description: truncateDiscordCommandDescription({
+        value: arg.description,
+        label: `command:${commandLabel} arg:${arg.name}`,
+      }),
+      type: ApplicationCommandOptionType.String,
+      required,
+      choices,
+      autocomplete,
+    };
+  }) satisfies CommandOptions;
+}

package/src/monitor/native-command.runtime.ts

@@ -0,0 +1,51 @@
+import { resolveDirectStatusReplyForSession } from "autobot/plugin-sdk/command-status-runtime";
+import * as pluginRuntime from "autobot/plugin-sdk/plugin-runtime";
+import { dispatchReplyWithDispatcher } from "autobot/plugin-sdk/reply-dispatch-runtime";
+import { resolveDiscordNativeInteractionRouteState } from "./native-command-route.js";
+
+export const nativeCommandRuntime = {
+  matchPluginCommand: pluginRuntime.matchPluginCommand,
+  executePluginCommand: pluginRuntime.executePluginCommand,
+  dispatchReplyWithDispatcher,
+  resolveDirectStatusReplyForSession,
+  resolveDiscordNativeInteractionRouteState,
+};
+
+export const testing = {
+  setMatchPluginCommand(
+    next: typeof pluginRuntime.matchPluginCommand,
+  ): typeof pluginRuntime.matchPluginCommand {
+    const previous = nativeCommandRuntime.matchPluginCommand;
+    nativeCommandRuntime.matchPluginCommand = next;
+    return previous;
+  },
+  setExecutePluginCommand(
+    next: typeof pluginRuntime.executePluginCommand,
+  ): typeof pluginRuntime.executePluginCommand {
+    const previous = nativeCommandRuntime.executePluginCommand;
+    nativeCommandRuntime.executePluginCommand = next;
+    return previous;
+  },
+  setDispatchReplyWithDispatcher(
+    next: typeof dispatchReplyWithDispatcher,
+  ): typeof dispatchReplyWithDispatcher {
+    const previous = nativeCommandRuntime.dispatchReplyWithDispatcher;
+    nativeCommandRuntime.dispatchReplyWithDispatcher = next;
+    return previous;
+  },
+  setResolveDirectStatusReplyForSession(
+    next: typeof resolveDirectStatusReplyForSession,
+  ): typeof resolveDirectStatusReplyForSession {
+    const previous = nativeCommandRuntime.resolveDirectStatusReplyForSession;
+    nativeCommandRuntime.resolveDirectStatusReplyForSession = next;
+    return previous;
+  },
+  setResolveDiscordNativeInteractionRouteState(
+    next: typeof resolveDiscordNativeInteractionRouteState,
+  ): typeof resolveDiscordNativeInteractionRouteState {
+    const previous = nativeCommandRuntime.resolveDiscordNativeInteractionRouteState;
+    nativeCommandRuntime.resolveDiscordNativeInteractionRouteState = next;
+    return previous;
+  },
+};
+export { testing as __testing };