@llblab/pi-telegram 0.7.1 → 0.8.0

package/lib/text-groups.ts

@@ -0,0 +1,203 @@
+/**
+ * Telegram text-group coalescing helpers
+ * Zones: telegram inbound, queue admission, split-message recovery
+ * Owns conservative delayed grouping for Telegram text messages that look like automatic long-message splits
+ */
+
+const TELEGRAM_TEXT_GROUP_DEBOUNCE_MS = 700;
+const TELEGRAM_TEXT_GROUP_MIN_SPLIT_LENGTH = 3600;
+
+export interface TelegramTextGroupMessage {
+  message_id: number;
+  media_group_id?: string;
+  chat: { id: number };
+  from?: { id: number; is_bot?: boolean };
+  text?: string;
+  caption?: string;
+}
+
+export interface TelegramTextGroupState<TMessage, TContext = unknown> {
+  messages: TMessage[];
+  context?: TContext;
+  flushTimer?: ReturnType<typeof setTimeout>;
+}
+
+export interface TelegramTextGroupController<TMessage, TContext = unknown> {
+  queueMessage: (options: {
+    message: TMessage;
+    context: TContext;
+    dispatchMessages: (messages: TMessage[], ctx: TContext) => void;
+  }) => boolean;
+  clear: () => void;
+}
+
+export interface TelegramTextGroupControllerOptions {
+  debounceMs?: number;
+  minSplitLength?: number;
+  setTimer?: (
+    callback: () => void,
+    ms: number,
+  ) => ReturnType<typeof setTimeout>;
+  clearTimer?: (timer: ReturnType<typeof setTimeout>) => void;
+}
+
+export interface TelegramTextGroupDispatchRuntime<
+  TMessage extends TelegramTextGroupMessage,
+  TContext,
+> {
+  handleMessage: (message: TMessage, ctx: TContext) => Promise<void>;
+}
+
+export interface TelegramGroupedInputClearerDeps {
+  clearMediaGroups: () => void;
+  clearTextGroups: () => void;
+}
+
+function extractTelegramTextGroupText(
+  message: TelegramTextGroupMessage,
+): string {
+  return typeof message.text === "string" ? message.text : "";
+}
+
+function isTelegramTextGroupCommand(text: string): boolean {
+  return text.trimStart().startsWith("/");
+}
+
+function getTelegramTextGroupKey(
+  message: TelegramTextGroupMessage,
+): string | undefined {
+  if (message.media_group_id) return undefined;
+  if (!message.from || message.from.is_bot) return undefined;
+  if (typeof message.text !== "string") return undefined;
+  return `${message.chat.id}:${message.from.id}`;
+}
+
+function canStartTelegramTextGroup(
+  message: TelegramTextGroupMessage,
+  minSplitLength: number,
+): boolean {
+  const text = extractTelegramTextGroupText(message);
+  return text.length >= minSplitLength && !isTelegramTextGroupCommand(text);
+}
+
+function canAppendTelegramTextGroupMessage<
+  TMessage extends TelegramTextGroupMessage,
+>(
+  state: TelegramTextGroupState<TMessage, unknown>,
+  message: TMessage,
+): boolean {
+  const text = extractTelegramTextGroupText(message);
+  const previous = state.messages.at(-1);
+  return (
+    !!previous &&
+    message.message_id > previous.message_id &&
+    message.message_id <= previous.message_id + 2 &&
+    text.length > 0 &&
+    !isTelegramTextGroupCommand(text)
+  );
+}
+
+export function queueTelegramTextGroupMessage<
+  TMessage extends TelegramTextGroupMessage,
+  TContext = unknown,
+>(options: {
+  message: TMessage;
+  context: TContext;
+  groups: Map<string, TelegramTextGroupState<TMessage, TContext>>;
+  debounceMs: number;
+  minSplitLength: number;
+  setTimer: (callback: () => void, ms: number) => ReturnType<typeof setTimeout>;
+  clearTimer: (timer: ReturnType<typeof setTimeout>) => void;
+  dispatchMessages: (messages: TMessage[], ctx: TContext) => void;
+}): boolean {
+  const key = getTelegramTextGroupKey(options.message);
+  if (!key) return false;
+  const existing = options.groups.get(key);
+  if (
+    !existing &&
+    !canStartTelegramTextGroup(options.message, options.minSplitLength)
+  )
+    return false;
+  if (existing && !canAppendTelegramTextGroupMessage(existing, options.message))
+    return false;
+  const state = existing ?? { messages: [] };
+  state.messages.push(options.message);
+  state.context = options.context;
+  if (state.flushTimer) options.clearTimer(state.flushTimer);
+  state.flushTimer = options.setTimer(() => {
+    const queued = options.groups.get(key);
+    options.groups.delete(key);
+    if (!queued || queued.context === undefined) return;
+    options.dispatchMessages(queued.messages, queued.context);
+  }, options.debounceMs);
+  options.groups.set(key, state);
+  return true;
+}
+
+export function createTelegramTextGroupController<
+  TMessage extends TelegramTextGroupMessage,
+  TContext = unknown,
+>(
+  options: TelegramTextGroupControllerOptions = {},
+): TelegramTextGroupController<TMessage, TContext> {
+  const groups = new Map<string, TelegramTextGroupState<TMessage, TContext>>();
+  const debounceMs = options.debounceMs ?? TELEGRAM_TEXT_GROUP_DEBOUNCE_MS;
+  const minSplitLength =
+    options.minSplitLength ?? TELEGRAM_TEXT_GROUP_MIN_SPLIT_LENGTH;
+  const setTimer =
+    options.setTimer ??
+    ((callback: () => void, ms: number): ReturnType<typeof setTimeout> =>
+      setTimeout(callback, ms));
+  const clearTimer = options.clearTimer ?? clearTimeout;
+  return {
+    queueMessage: ({ message, context, dispatchMessages }) =>
+      queueTelegramTextGroupMessage({
+        message,
+        context,
+        groups,
+        debounceMs,
+        minSplitLength,
+        setTimer,
+        clearTimer,
+        dispatchMessages,
+      }),
+    clear: () => {
+      for (const state of groups.values()) {
+        if (state.flushTimer) clearTimer(state.flushTimer);
+      }
+      groups.clear();
+    },
+  };
+}
+
+export function createTelegramTextGroupDispatchRuntime<
+  TMessage extends TelegramTextGroupMessage,
+  TContext,
+>(deps: {
+  textGroups: TelegramTextGroupController<TMessage, TContext>;
+  dispatchMessages: (messages: TMessage[], ctx: TContext) => Promise<void>;
+  dispatchSingleMessage: (message: TMessage, ctx: TContext) => Promise<void>;
+}): TelegramTextGroupDispatchRuntime<TMessage, TContext> {
+  return {
+    handleMessage: async (message, ctx) => {
+      const queuedTextGroup = deps.textGroups.queueMessage({
+        message,
+        context: ctx,
+        dispatchMessages: (messages, queuedCtx) => {
+          void deps.dispatchMessages(messages, queuedCtx);
+        },
+      });
+      if (queuedTextGroup) return;
+      await deps.dispatchSingleMessage(message, ctx);
+    },
+  };
+}
+
+export function createTelegramGroupedInputClearer(
+  deps: TelegramGroupedInputClearerDeps,
+): () => void {
+  return () => {
+    deps.clearMediaGroups();
+    deps.clearTextGroups();
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-telegram",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "private": false,
   "description": "Better Telegram DM bridge extension for π",
   "type": "module",

package/docs/attachment-handlers.md

@@ -1,50 +0,0 @@
-# Attachment Handlers
-
-`pi-telegram` can run ordered inbound attachment handlers after downloading files and before the Telegram turn enters the π queue.
-
-This document is the local adaptation of the portable [Command Template Standard](./command-templates.md).
-
-## Config Shape
-
-`telegram.json` may define `attachmentHandlers`:
-
-```json
-{
-  "attachmentHandlers": [
-    {
-      "type": "voice",
-      "template": "/path/to/stt1 --file {file} --lang {lang=ru}"
-    },
-    {
-      "mime": "audio/*",
-      "template": "/path/to/stt2 --file {file} --lang {lang=ru}"
-    }
-  ]
-}
-```
-
-Handlers match by `type`, `mime`, or `match`. Wildcards such as `audio/*` are accepted. Each matching handler must provide `template`; a string is one command, and an array is ordered composition. Top-level `args` and `defaults` apply to composed steps unless a step defines private values. The command-template default timeout applies automatically. Legacy configs may still use `pipe` as a local alias.
-
-## Template Placeholders
-
-Attachment handlers support these built-in placeholders:
-
-| Placeholder | Value                                                            |
-| ----------- | ---------------------------------------------------------------- |
-| `{file}`    | Full local path to the downloaded file                           |
-| `{mime}`    | MIME type if known                                               |
-| `{type}`    | Attachment kind such as `voice`, `audio`, `document`, or `photo` |
-
-`defaults` may provide additional placeholder values such as `{lang}` or `{model}`. `args` is only a string-array declaration of supported placeholders; defaults belong in `defaults` or inline placeholders such as `{lang=ru}`. Examples prefer explicit flag-style CLIs for readability, but positional forms such as `/path/to/stt {file} {lang=ru} {model=voxtral-mini-latest}` are equally valid when the target script supports them.
-
-If a top-level one-step handler template has no `{file}` placeholder, the downloaded file path is appended as the last command arg as a one-step handler convenience. Composition steps are plain command templates and do not receive implicit file-path args; include `{file}` explicitly where needed.
-
-## Ordered Fallbacks
-
-A handler list is ordered. For each attachment, matching handlers run in list order and stop after the first successful handler. A composed handler counts as one handler for fallback purposes: if any step fails, the next matching handler is tried.
-
-If a matching handler fails with a non-zero exit code, the runtime records diagnostics and tries the next matching handler. If every matching handler fails, the attachment remains visible in the prompt as a normal local file reference.
-
-## Prompt Output
-
-Local attachments stay in the prompt under `[attachments] <directory>` with relative file entries. Successful handler stdout is added under `[outputs]`. For composed handlers, each step receives the previous step's stdout on stdin by default, and stdout from the last successful step is used as the handler output. Empty output and failed handler output are omitted from the prompt text.

package/lib/attachment-handlers.ts

@@ -1,423 +0,0 @@
-/**
- * Telegram inbound attachment handler pipeline
- * Zones: telegram inbound, command templates, prompt preparation
- * Owns MIME/type matching, command-template execution, fallback handling, and prompt injection before prompt enqueueing
- */
-
-import { basename } from "node:path";
-
-import {
-  buildCommandTemplateInvocation,
-  expandCommandTemplateConfigs,
-  normalizeCommandTemplateConfig,
-  type CommandTemplateConfig,
-  type CommandTemplateObjectConfig,
-} from "./command-templates.ts";
-
-const DEFAULT_ATTACHMENT_HANDLER_TIMEOUT_MS = 120_000;
-
-type TelegramAttachmentCommandTemplateConfig =
-  | string
-  | CommandTemplateObjectConfig;
-
-export interface TelegramAttachmentHandlerConfig {
-  match?: string | string[];
-  mime?: string | string[];
-  type?: string | string[];
-  template?: string | TelegramAttachmentCommandTemplateConfig[];
-  pipe?: TelegramAttachmentCommandTemplateConfig[];
-  args?: string[];
-  defaults?: Record<string, unknown>;
-  timeout?: number;
-}
-
-export interface TelegramAttachmentHandlerFile {
-  path: string;
-  fileName?: string;
-  mimeType?: string;
-  kind?: string;
-  isImage?: boolean;
-}
-
-export interface TelegramAttachmentHandlerOutput {
-  file: TelegramAttachmentHandlerFile;
-  output: string;
-  handler: TelegramAttachmentHandlerConfig;
-}
-
-export interface TelegramAttachmentHandlerProcessResult<
-  TFile extends TelegramAttachmentHandlerFile = TelegramAttachmentHandlerFile,
-> {
-  rawText: string;
-  promptFiles: TFile[];
-  handlerOutputs: string[];
-  handledFiles: TelegramAttachmentHandlerOutput[];
-}
-
-export interface TelegramAttachmentHandlerExecOptions {
-  cwd?: string;
-  timeout?: number;
-  signal?: AbortSignal;
-  stdin?: string;
-}
-
-export interface TelegramAttachmentHandlerExecResult {
-  stdout: string;
-  stderr: string;
-  code: number;
-  killed: boolean;
-}
-
-export interface TelegramAttachmentHandlerRuntimeContext {
-  cwd: string;
-}
-
-export interface TelegramAttachmentHandlerRuntimeDeps<TContext> {
-  getHandlers: () => TelegramAttachmentHandlerConfig[] | undefined;
-  execCommand: (
-    command: string,
-    args: string[],
-    options?: TelegramAttachmentHandlerExecOptions,
-  ) => Promise<TelegramAttachmentHandlerExecResult>;
-  getCwd: (ctx: TContext) => string;
-  recordRuntimeEvent?: (
-    category: string,
-    error: unknown,
-    details?: Record<string, unknown>,
-  ) => void;
-}
-
-export interface TelegramAttachmentHandlerRuntime<TContext> {
-  process: <TFile extends TelegramAttachmentHandlerFile>(
-    files: TFile[],
-    rawText: string,
-    ctx: TContext,
-  ) => Promise<TelegramAttachmentHandlerProcessResult<TFile>>;
-}
-
-interface AttachmentHandlerInvocation {
-  command: string;
-  args: string[];
-}
-
-function normalizeStringList(value: string | string[] | undefined): string[] {
-  if (Array.isArray(value)) {
-    return value
-      .map(String)
-      .map((item) => item.trim())
-      .filter(Boolean);
-  }
-  if (typeof value === "string" && value.trim()) return [value.trim()];
-  return [];
-}
-
-function matchesWildcard(pattern: string, value: string | undefined): boolean {
-  if (!value) return false;
-  const normalizedPattern = pattern.toLowerCase();
-  const normalizedValue = value.toLowerCase();
-  if (normalizedPattern === "*") return true;
-  const escaped = normalizedPattern
-    .replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
-    .replace(/\\\*/g, ".*");
-  return new RegExp(`^${escaped}$`).test(normalizedValue);
-}
-
-function handlerHasSelectors(
-  handler: TelegramAttachmentHandlerConfig,
-): boolean {
-  return (
-    normalizeStringList(handler.match).length > 0 ||
-    normalizeStringList(handler.mime).length > 0 ||
-    normalizeStringList(handler.type).length > 0
-  );
-}
-
-function matchesAnyPattern(
-  patterns: string[],
-  value: string | undefined,
-): boolean {
-  return patterns.some((pattern) => matchesWildcard(pattern, value));
-}
-
-export function telegramAttachmentHandlerMatchesFile(
-  handler: TelegramAttachmentHandlerConfig,
-  file: TelegramAttachmentHandlerFile,
-): boolean {
-  if (!handlerHasSelectors(handler)) return true;
-  const matchPatterns = normalizeStringList(handler.match);
-  const mimePatterns = normalizeStringList(handler.mime);
-  const typePatterns = normalizeStringList(handler.type);
-  if (matchesAnyPattern(mimePatterns, file.mimeType)) return true;
-  if (matchesAnyPattern(typePatterns, file.kind)) return true;
-  if (matchesAnyPattern(matchPatterns, file.mimeType)) return true;
-  return matchesAnyPattern(matchPatterns, file.kind);
-}
-
-export function findTelegramAttachmentHandlers(
-  handlers: TelegramAttachmentHandlerConfig[] | undefined,
-  file: TelegramAttachmentHandlerFile,
-): TelegramAttachmentHandlerConfig[] {
-  if (!Array.isArray(handlers)) return [];
-  return handlers.filter(
-    (handler) =>
-      !!handler &&
-      typeof handler === "object" &&
-      telegramAttachmentHandlerMatchesFile(handler, file),
-  );
-}
-
-export function findTelegramAttachmentHandler(
-  handlers: TelegramAttachmentHandlerConfig[] | undefined,
-  file: TelegramAttachmentHandlerFile,
-): TelegramAttachmentHandlerConfig | undefined {
-  return findTelegramAttachmentHandlers(handlers, file)[0];
-}
-
-function hasAttachmentFilePlaceholder(value: string): boolean {
-  return /\{file\}/.test(value);
-}
-
-function getTelegramAttachmentHandlerTemplateValues(
-  file: TelegramAttachmentHandlerFile,
-): Record<string, string> {
-  return {
-    file: file.path,
-    mime: file.mimeType ?? "",
-    type: file.kind ?? "",
-  };
-}
-
-function buildTelegramAttachmentTemplateInvocation(
-  handler: CommandTemplateConfig,
-  file: TelegramAttachmentHandlerFile,
-  cwd: string,
-  appendFileIfMissing = true,
-): AttachmentHandlerInvocation {
-  const values = getTelegramAttachmentHandlerTemplateValues(file);
-  const templateConfig = normalizeCommandTemplateConfig(handler);
-  const hadFilePlaceholder =
-    typeof templateConfig.template === "string"
-      ? hasAttachmentFilePlaceholder(templateConfig.template)
-      : false;
-  const invocation = buildCommandTemplateInvocation(handler, values, cwd, {
-    emptyMessage: "Attachment handler template is empty",
-    missingLabel: "attachment handler template",
-  });
-  if (appendFileIfMissing && !hadFilePlaceholder)
-    invocation.args.push(file.path);
-  return invocation;
-}
-
-export function buildTelegramAttachmentHandlerInvocation(
-  handler: CommandTemplateConfig,
-  file: TelegramAttachmentHandlerFile,
-  cwd: string,
-  appendFileIfMissing = true,
-): AttachmentHandlerInvocation {
-  const { template } = normalizeCommandTemplateConfig(handler);
-  if (!template) throw new Error("Attachment handler template is required");
-  return buildTelegramAttachmentTemplateInvocation(
-    handler,
-    file,
-    cwd,
-    appendFileIfMissing,
-  );
-}
-
-function getTelegramAttachmentHandlerConfiguredTimeout(
-  handler: TelegramAttachmentCommandTemplateConfig,
-): number | undefined {
-  const timeout = typeof handler === "string" ? undefined : handler.timeout;
-  return typeof timeout === "number" && Number.isFinite(timeout) && timeout > 0
-    ? timeout
-    : undefined;
-}
-
-function getTelegramAttachmentHandlerTimeout(
-  handler: TelegramAttachmentCommandTemplateConfig,
-): number {
-  return (
-    getTelegramAttachmentHandlerConfiguredTimeout(handler) ??
-    DEFAULT_ATTACHMENT_HANDLER_TIMEOUT_MS
-  );
-}
-
-function getRemainingTelegramAttachmentTimeout(
-  timeout: number,
-  startedAt: number,
-): number {
-  return Math.max(1, timeout - (Date.now() - startedAt));
-}
-
-function getTelegramAttachmentCompositionStepTimeout(
-  handler: TelegramAttachmentHandlerConfig,
-  step: TelegramAttachmentCommandTemplateConfig,
-  startedAt: number,
-): number {
-  const remaining = getRemainingTelegramAttachmentTimeout(
-    getTelegramAttachmentHandlerTimeout(handler),
-    startedAt,
-  );
-  const stepTimeout = getTelegramAttachmentHandlerConfiguredTimeout(step);
-  return stepTimeout === undefined
-    ? remaining
-    : Math.min(stepTimeout, remaining);
-}
-
-function getTelegramAttachmentHandlerKind(
-  handler: TelegramAttachmentHandlerConfig,
-): string {
-  if (Array.isArray(handler.template) || handler.pipe?.length)
-    return "composition";
-  if (handler.template) return "template";
-  return "unknown";
-}
-
-function formatTelegramAttachmentHandlerFailure(
-  result: TelegramAttachmentHandlerExecResult,
-): string {
-  const parts = [
-    `Attachment handler exited with code ${result.code}${result.killed ? " (killed)" : ""}`,
-  ];
-  if (result.stderr.trim()) parts.push(`stderr:\n${result.stderr.trimEnd()}`);
-  if (result.stdout.trim()) parts.push(`stdout:\n${result.stdout.trimEnd()}`);
-  return parts.join("\n\n");
-}
-
-async function executeTelegramAttachmentHandlerInvocation(
-  handler: TelegramAttachmentCommandTemplateConfig,
-  file: TelegramAttachmentHandlerFile,
-  cwd: string,
-  deps: Pick<TelegramAttachmentHandlerRuntimeDeps<unknown>, "execCommand">,
-  appendFileIfMissing = true,
-  timeout = getTelegramAttachmentHandlerTimeout(handler),
-  stdin?: string,
-): Promise<string> {
-  const invocation = buildTelegramAttachmentHandlerInvocation(
-    handler,
-    file,
-    cwd,
-    appendFileIfMissing,
-  );
-  const result = await deps.execCommand(invocation.command, invocation.args, {
-    cwd,
-    timeout,
-    ...(typeof handler === "object" && handler.retry !== undefined
-      ? { retry: handler.retry }
-      : {}),
-    ...(stdin !== undefined ? { stdin } : {}),
-  });
-  if (result.code !== 0)
-    throw new Error(formatTelegramAttachmentHandlerFailure(result));
-  return result.stdout;
-}
-
-function getTelegramAttachmentHandlerCompositionSteps(
-  handler: TelegramAttachmentHandlerConfig,
-): TelegramAttachmentCommandTemplateConfig[] {
-  if (Array.isArray(handler.template)) {
-    return expandCommandTemplateConfigs(
-      handler,
-    ) as TelegramAttachmentCommandTemplateConfig[];
-  }
-  if (handler.pipe?.length) {
-    return expandCommandTemplateConfigs({
-      ...handler,
-      template: handler.pipe,
-    }) as TelegramAttachmentCommandTemplateConfig[];
-  }
-  return [];
-}
-
-async function executeTelegramAttachmentHandler(
-  handler: TelegramAttachmentHandlerConfig,
-  file: TelegramAttachmentHandlerFile,
-  cwd: string,
-  deps: Pick<TelegramAttachmentHandlerRuntimeDeps<unknown>, "execCommand">,
-): Promise<string> {
-  const steps = getTelegramAttachmentHandlerCompositionSteps(handler);
-  if (steps.length === 0) {
-    const output = await executeTelegramAttachmentHandlerInvocation(
-      handler,
-      file,
-      cwd,
-      deps,
-    );
-    return output.trim();
-  }
-  const startedAt = Date.now();
-  let output = "";
-  for (const [index, step] of steps.entries()) {
-    try {
-      output = await executeTelegramAttachmentHandlerInvocation(
-        step,
-        file,
-        cwd,
-        deps,
-        false,
-        getTelegramAttachmentCompositionStepTimeout(handler, step, startedAt),
-        index === 0 ? undefined : output,
-      );
-    } catch (error) {
-      if (typeof step === "object" && step.critical) throw error;
-      output = "";
-    }
-  }
-  return output.trim();
-}
-
-export async function processTelegramAttachmentHandlers<
-  TFile extends TelegramAttachmentHandlerFile,
->(options: {
-  files: TFile[];
-  rawText: string;
-  handlers?: TelegramAttachmentHandlerConfig[];
-  cwd: string;
-  execCommand: TelegramAttachmentHandlerRuntimeDeps<unknown>["execCommand"];
-  recordRuntimeEvent?: TelegramAttachmentHandlerRuntimeDeps<unknown>["recordRuntimeEvent"];
-}): Promise<TelegramAttachmentHandlerProcessResult<TFile>> {
-  const promptFiles: TFile[] = [...options.files];
-  const outputs: TelegramAttachmentHandlerOutput[] = [];
-  for (const file of options.files) {
-    const handlers = findTelegramAttachmentHandlers(options.handlers, file);
-    for (const handler of handlers) {
-      try {
-        const output = await executeTelegramAttachmentHandler(
-          handler,
-          file,
-          options.cwd,
-          options,
-        );
-        if (output) outputs.push({ file, output, handler });
-        break;
-      } catch (error) {
-        options.recordRuntimeEvent?.("attachment-handler", error, {
-          fileName: file.fileName || basename(file.path),
-          handler: getTelegramAttachmentHandlerKind(handler),
-        });
-      }
-    }
-  }
-  return {
-    rawText: options.rawText,
-    promptFiles,
-    handlerOutputs: outputs.map((output) => output.output),
-    handledFiles: outputs,
-  };
-}
-
-export function createTelegramAttachmentHandlerRuntime<TContext>(
-  deps: TelegramAttachmentHandlerRuntimeDeps<TContext>,
-): TelegramAttachmentHandlerRuntime<TContext> {
-  return {
-    process: (files, rawText, ctx) =>
-      processTelegramAttachmentHandlers({
-        files,
-        rawText,
-        handlers: deps.getHandlers(),
-        cwd: deps.getCwd(ctx),
-        execCommand: deps.execCommand,
-        recordRuntimeEvent: deps.recordRuntimeEvent,
-      }),
-  };
-}