harness-mix 0.1.0

package/src/native-ui/renderer-extension/src/renderer-external-steering.ts

@@ -0,0 +1,339 @@
+import { threadOwnershipListResultSchema } from "@codexhost/shared-contracts";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+type RendererMethod = (...args: unknown[]) => unknown;
+interface SteeringManager {
+  sendRequest: RendererMethod;
+  steerTurn: RendererMethod;
+  startTurn: RendererMethod;
+  getTurnCoordinator: RendererMethod;
+  getStreamRole?: RendererMethod;
+}
+
+function isManager(value: unknown): value is SteeringManager {
+  return (
+    isRecord(value) &&
+    ["sendRequest", "steerTurn", "startTurn", "getTurnCoordinator"].every(
+      (key) => typeof value[key] === "function",
+    )
+  );
+}
+
+function submissionHost(manager: SteeringManager): {
+  getActiveTurnId(threadId: string): unknown;
+  hasPendingTurnStart(threadId: string): unknown;
+} {
+  const coordinator = manager.getTurnCoordinator();
+  const options = isRecord(coordinator) ? coordinator.options : null;
+  const host = isRecord(options) ? options.submissionHost : null;
+  if (
+    !isRecord(host) ||
+    typeof host.getActiveTurnId !== "function" ||
+    typeof host.hasPendingTurnStart !== "function"
+  ) {
+    throw new Error("Desktop turn submission binding is unavailable");
+  }
+  return {
+    getActiveTurnId: (threadId) => (host.getActiveTurnId as RendererMethod).call(host, threadId),
+    hasPendingTurnStart: (threadId) =>
+      (host.hasPendingTurnStart as RendererMethod).call(host, threadId),
+  };
+}
+
+type SteeringMethodName = "sendRequest" | "steerTurn";
+
+function installSteeringMethods(
+  manager: SteeringManager,
+  replacements: Record<SteeringMethodName, RendererMethod>,
+): (name: SteeringMethodName) => void {
+  const originalPrototype: object | null = Object.getPrototypeOf(manager);
+  const overrides: object = Object.create(originalPrototype);
+  const names = ["sendRequest", "steerTurn"] as const;
+  const descriptors = new Map(
+    names.map((name) => [name, Object.getOwnPropertyDescriptor(manager, name)]),
+  );
+  for (const name of names) {
+    const own = descriptors.get(name);
+    // Desktop's RpcTarget forbids own properties over RPC, including functions.
+    // Override inherited methods on a private prototype, never on the instance
+    // or the shared class prototype. Plain-object targets retain their own shape.
+    Object.defineProperty(own ? manager : overrides, name, {
+      configurable: own?.configurable ?? true,
+      enumerable: own?.enumerable ?? false,
+      writable: true,
+      value: replacements[name],
+    });
+  }
+  if (names.some((name) => !descriptors.get(name))) {
+    Object.setPrototypeOf(manager, overrides);
+  }
+  return (name) => {
+    const own = descriptors.get(name);
+    const holder = own ? manager : overrides;
+    if (Reflect.get(holder, name) === replacements[name]) {
+      if (own) Object.defineProperty(manager, name, own);
+      else Reflect.deleteProperty(overrides, name);
+    }
+    if (
+      Object.getPrototypeOf(manager) === overrides &&
+      names.every((key) => !Object.hasOwn(overrides, key))
+    ) {
+      Object.setPrototypeOf(manager, originalPrototype);
+    }
+  };
+}
+
+const INTERRUPTED_QUEUE_REASON = "Interrupted before the steer was accepted.";
+
+async function preserveQueuedFollowUps(
+  manager: SteeringManager,
+  threadId: string,
+): Promise<() => void> {
+  const coordinator = manager.getTurnCoordinator();
+  if (
+    !isRecord(coordinator) ||
+    typeof coordinator.loadMessages !== "function" ||
+    typeof coordinator.readMessages !== "function" ||
+    typeof coordinator.mutate !== "function"
+  ) {
+    throw new Error("Desktop follow-up queue binding is unavailable");
+  }
+  await coordinator.loadMessages.call(coordinator, threadId);
+  const messages: unknown = coordinator.readMessages.call(coordinator, threadId);
+  if (!Array.isArray(messages)) throw new Error("Desktop follow-up queue is unavailable");
+  const alreadyPaused = new Set(
+    messages
+      .filter((message) => isRecord(message) && message.pausedReason != null)
+      .map((message) => (message as Record<string, unknown>).id),
+  );
+  return () => {
+    // A real interrupted terminal pauses Desktop's queue. Resume only pauses introduced
+    // by this replacement, including messages queued while cancellation was pending.
+    (coordinator.mutate as RendererMethod).call(coordinator, threadId, (current: unknown) => {
+      if (!Array.isArray(current)) return current;
+      return current.map((message) => {
+        if (
+          !isRecord(message) ||
+          alreadyPaused.has(message.id) ||
+          message.pausedReason !== INTERRUPTED_QUEUE_REASON
+        )
+          return message;
+        const resumed = { ...message };
+        delete resumed.pausedReason;
+        return resumed;
+      });
+    });
+  };
+}
+
+/**
+ * Use Desktop's normal start presentation BEFORE it creates an old-Turn steering Item.
+ * Only this operation's outgoing start RPC becomes steer; Host owns stop/wait/start.
+ * Official Threads retain the original steer implementation and response semantics.
+ */
+export function installRendererExternalSteering(target: unknown): (() => void) | null {
+  if (!isManager(target)) return null;
+  const manager = target;
+  const originalSteer = manager.steerTurn;
+  const originalSend = manager.sendRequest;
+  const routes = new Map<string, { threadId: string; expectedTurnId: string }>();
+  const pending = new Map<
+    string,
+    { messageId: string; fingerprint: string; promise: Promise<unknown> }
+  >();
+  let disposed = false;
+
+  const send: RendererMethod = function (method, params, options) {
+    const messageId = isRecord(params) ? params.clientUserMessageId : null;
+    const route =
+      typeof messageId === "string" && isRecord(params)
+        ? routes.get(`${params.threadId}\u0000${messageId}`)
+        : undefined;
+    if (
+      method !== "turn/start" ||
+      !isRecord(params) ||
+      !route ||
+      route.threadId !== params.threadId
+    ) {
+      return originalSend.call(manager, method, params, options);
+    }
+    if (disposed) return Promise.reject(new Error("External steering binding was disposed"));
+    return Promise.resolve(
+      originalSend.call(
+        manager,
+        "turn/steer",
+        {
+          threadId: route.threadId,
+          expectedTurnId: route.expectedTurnId,
+          clientUserMessageId: messageId,
+          input: params.input,
+          additionalContext: params.additionalContext,
+          responsesapiClientMetadata: params.responsesapiClientMetadata,
+        },
+        options,
+      ),
+    ).then((response) => {
+      if (!isRecord(response) || typeof response.turnId !== "string" || !response.turnId) {
+        throw new Error("External steering returned no replacement Turn identity");
+      }
+      return {
+        turn: {
+          id: response.turnId,
+          status: "inProgress",
+          items: [],
+          error: null,
+          startedAt: null,
+          completedAt: null,
+          durationMs: null,
+          itemsView: "full",
+        },
+      };
+    });
+  };
+
+  const steer: RendererMethod = async function (...args) {
+    const [
+      threadId,
+      input,
+      restoreMessage,
+      serviceTier,
+      attachments,
+      clientUserMessageId,
+      additionalContext,
+      toolOutput,
+      onMessageAdded,
+    ] = args;
+    if (typeof threadId !== "string") return originalSteer.apply(manager, args);
+    const role = manager.getStreamRole?.(threadId);
+    // Let Desktop forward to the owning window; its manager performs the replacement.
+    if (isRecord(role) && role.role === "follower") return originalSteer.apply(manager, args);
+    let host: ReturnType<typeof submissionHost> | null = null;
+    let expectedTurnId: unknown;
+    try {
+      host = submissionHost(manager);
+      expectedTurnId = host.getActiveTurnId(threadId);
+    } catch {
+      // Official steering must not depend on our additional presentation binding.
+    }
+    const ownership = threadOwnershipListResultSchema.parse(
+      await originalSend.call(manager, "codexhost/thread/ownership/list", {
+        threadIds: [threadId],
+      }),
+    );
+    const owner = ownership.threads.find((thread) => thread.threadId === threadId)?.owner;
+    if (!owner) throw new Error("Thread ownership could not be resolved for steering");
+    if (disposed) throw new Error("External steering binding was disposed");
+    if (owner === "codex") return originalSteer.apply(manager, args);
+    if (!host) throw new Error("Desktop turn submission binding is unavailable");
+    const currentRole = manager.getStreamRole?.(threadId);
+    if (isRecord(currentRole) && currentRole.role === "follower")
+      return originalSteer.apply(manager, args);
+    if (
+      !Array.isArray(input) ||
+      input.length === 0 ||
+      input.some(
+        (item) => !isRecord(item) || !(
+          item.type === "text" && typeof item.text === "string" ||
+          item.type === "localImage" && typeof item.path === "string" && item.path.length > 0 ||
+          item.type === "image" && typeof item.url === "string" && item.url.startsWith("data:image/")
+        ),
+      ) ||
+      !input.some((item) => isRecord(item) && (item.type !== "text" || typeof item.text === "string" && item.text.trim()))
+    ) {
+      throw new Error("External steering requires non-empty text input or images");
+    }
+    if (toolOutput != null) throw new Error("External steering cannot replace a tool response");
+    if (!isRecord(restoreMessage) || !isRecord(restoreMessage.context)) {
+      throw new Error("Desktop steering message context is unavailable");
+    }
+    const messageId =
+      typeof clientUserMessageId === "string" && clientUserMessageId
+        ? clientUserMessageId
+        : typeof restoreMessage.id === "string" && restoreMessage.id
+          ? restoreMessage.id
+          : crypto.randomUUID();
+    const fingerprint = JSON.stringify(input);
+    const existing = pending.get(threadId);
+    if (existing) {
+      if (existing.messageId === messageId && existing.fingerprint === fingerprint)
+        return existing.promise;
+      throw new Error("This Thread is already changing direction");
+    }
+    if (expectedTurnId != null && (typeof expectedTurnId !== "string" || !expectedTurnId)) {
+      throw new Error("Desktop active Turn identity is invalid");
+    }
+    if (expectedTurnId == null && host.hasPendingTurnStart(threadId)) {
+      throw new Error("Previous Turn submission has not been confirmed yet");
+    }
+    const context = restoreMessage.context;
+    const routeKey = `${threadId}\u0000${messageId}`;
+    if (typeof expectedTurnId === "string") routes.set(routeKey, { threadId, expectedTurnId });
+    const promise = Promise.resolve()
+      .then(async () => {
+        if (disposed) throw new Error("External steering binding was disposed");
+        const resumeQueue = await preserveQueuedFollowUps(manager, threadId);
+        if (disposed) throw new Error("External steering binding was disposed");
+        const response = await manager.startTurn(
+          threadId,
+          {
+            request: {
+              threadId,
+              input,
+              clientUserMessageId: messageId,
+              additionalContext,
+              responsesapiClientMetadata: restoreMessage.responsesapiClientMetadata,
+              cwd: restoreMessage.cwd,
+              serviceTier,
+              model: null,
+              effort: null,
+              collaborationMode: context.collaborationMode ?? null,
+            },
+            context: {
+              attachments: attachments ?? [],
+              commentAttachments: context.commentAttachments ?? [],
+              mcpAppModelContextAttachments: context.mcpAppModelContextAttachments,
+              useAppServerPermissionDefault: true,
+            },
+          },
+          onMessageAdded,
+        );
+        if (
+          !isRecord(response) ||
+          !isRecord(response.turn) ||
+          typeof response.turn.id !== "string"
+        ) {
+          throw new Error("Desktop returned no replacement Turn identity");
+        }
+        try {
+          resumeQueue();
+        } catch {
+          // Never turn an accepted input into a failed delivery (and invite a retry).
+          console.error("codexhost could not restore follow-up queue state after steering");
+        }
+        return { turnId: response.turn.id };
+      })
+      .finally(() => {
+        routes.delete(routeKey);
+        pending.delete(threadId);
+      });
+    pending.set(threadId, { messageId, fingerprint, promise });
+    return promise;
+  };
+
+  const restoreMethod = installSteeringMethods(manager, { sendRequest: send, steerTurn: steer });
+  return () => {
+    disposed = true;
+    restoreMethod("steerTurn");
+    // In-flight starts must fail closed, not accidentally become ordinary start RPCs.
+    if (pending.size === 0) {
+      restoreMethod("sendRequest");
+    } else {
+      void Promise.allSettled([...pending.values()].map(({ promise }) => promise)).then(() => {
+        restoreMethod("sendRequest");
+      });
+    }
+  };
+}

package/src/native-ui/renderer-extension/src/renderer-fork-control.ts

@@ -0,0 +1,273 @@
+import {
+  hostThreadIdSchema,
+  hostTurnIdSchema,
+  type HostThreadId,
+  type HostTurnId,
+} from "@codexhost/shared-contracts";
+
+import type { RendererModelClient } from "./renderer-model-client.js";
+import {
+  SIDEBAR_THREAD_HOST_ID_ATTRIBUTE,
+  SIDEBAR_THREAD_ROW_SELECTOR,
+  threadIdFromSidebarRowElement,
+} from "./renderer-sidebar-agent-icons.js";
+
+const RESPONSE_CONVERSATION_ATTRIBUTE = "data-response-annotation-conversation";
+const TURN_KEY_ATTRIBUTE = "data-content-search-turn-key";
+const OPEN_THREAD_TIMEOUT_MS = 5_000;
+
+function abortError(): Error {
+  return Object.assign(new Error("Thread opening was aborted"), { name: "AbortError" });
+}
+
+export function openRendererThread(
+  threadId: HostThreadId,
+  options: { hostId?: string; signal?: AbortSignal; timeoutMs?: number } = {},
+): Promise<void> {
+  const find = (): HTMLElement | null => {
+    for (const row of document.querySelectorAll<HTMLElement>(SIDEBAR_THREAD_ROW_SELECTOR)) {
+      if (
+        (options.hostId === undefined ||
+          row.getAttribute(SIDEBAR_THREAD_HOST_ID_ATTRIBUTE) === options.hostId) &&
+        threadIdFromSidebarRowElement(row) === threadId
+      ) {
+        return row;
+      }
+    }
+    return null;
+  };
+  if (options.signal?.aborted) return Promise.reject(abortError());
+  const current = find();
+  if (current) {
+    current.click();
+    return Promise.resolve();
+  }
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const cleanup = (): void => {
+      window.clearTimeout(timeout);
+      observer.disconnect();
+      options.signal?.removeEventListener("abort", onAbort);
+    };
+    const finish = (row: HTMLElement): void => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      row.click();
+      resolve();
+    };
+    const observer = new MutationObserver(() => {
+      const row = find();
+      if (row) finish(row);
+    });
+    const timeout = window.setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(new Error("Thread did not appear in the sidebar"));
+    }, options.timeoutMs ?? OPEN_THREAD_TIMEOUT_MS);
+    const onAbort = (): void => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(abortError());
+    };
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+    observer.observe(document.documentElement, { childList: true, subtree: true });
+    if (options.signal?.aborted) {
+      onAbort();
+      return;
+    }
+    const row = find();
+    if (row) finish(row);
+  });
+}
+
+export interface RendererForkTarget {
+  control: object;
+  isProjectlessConversation: boolean;
+  threadId: HostThreadId;
+  turnId: HostTurnId;
+}
+
+export interface RendererForkDom {
+  listen(onFork: (target: RendererForkTarget) => boolean): () => void;
+  openThread(threadId: HostThreadId): Promise<void>;
+  replay(target: RendererForkTarget): void;
+}
+
+export interface RendererForkControl {
+  dispose(): void;
+}
+
+export interface RendererForkContractInspection {
+  annotatedResponseCount: number;
+  candidateButtonCount: number;
+  verifiedButtonCount: number;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function firstFiber(element: Element): Record<string, unknown> | null {
+  const names = Object.getOwnPropertyNames(element).filter((name) =>
+    name.startsWith("__reactFiber$"),
+  );
+  const name = names[0];
+  if (names.length !== 1 || !name) return null;
+  const value = Object.getOwnPropertyDescriptor(element, name)?.value;
+  return isRecord(value) ? value : null;
+}
+
+export function rendererForkTargetFromButton(button: HTMLButtonElement): RendererForkTarget | null {
+  const annotation = button.closest<HTMLElement>(`[${RESPONSE_CONVERSATION_ATTRIBUTE}]`);
+  const turnElement = button.closest<HTMLElement>(`[${TURN_KEY_ATTRIBUTE}]`);
+  const threadId = hostThreadIdSchema.safeParse(
+    annotation?.getAttribute(RESPONSE_CONVERSATION_ATTRIBUTE),
+  );
+  const turnId = hostTurnIdSchema.safeParse(turnElement?.getAttribute(TURN_KEY_ATTRIBUTE));
+  if (!threadId.success || !turnId.success) return null;
+
+  const conversationIds = new Set<string>();
+  const turnIds = new Set<string>();
+  const hostIds = new Set<string>();
+  const projectlessStates = new Set<boolean>();
+  let hasForkCallback = false;
+  let fiber = firstFiber(button);
+  const buttonProps = fiber?.memoizedProps;
+  if (!isRecord(buttonProps) || !Object.hasOwn(buttonProps, "aria-busy")) return null;
+  for (let depth = 0; fiber && depth < 24; depth += 1) {
+    const props = fiber.memoizedProps;
+    if (isRecord(props)) {
+      if (typeof props.conversationId === "string") conversationIds.add(props.conversationId);
+      if (typeof props.turnId === "string") turnIds.add(props.turnId);
+      if (typeof props.hostId === "string") hostIds.add(props.hostId);
+      if (typeof props.isProjectlessConversation === "boolean") {
+        projectlessStates.add(props.isProjectlessConversation);
+      }
+      if (typeof props.onFork === "function") hasForkCallback = true;
+    }
+    fiber = isRecord(fiber.return) ? fiber.return : null;
+  }
+  if (
+    !hasForkCallback ||
+    conversationIds.size !== 1 ||
+    !conversationIds.has(threadId.data) ||
+    turnIds.size !== 1 ||
+    !turnIds.has(turnId.data) ||
+    hostIds.size !== 1 ||
+    !hostIds.has("local") ||
+    projectlessStates.size !== 1
+  ) {
+    return null;
+  }
+  return {
+    control: button,
+    isProjectlessConversation: projectlessStates.has(true),
+    threadId: threadId.data,
+    turnId: turnId.data,
+  };
+}
+
+export function inspectRendererForkContract(
+  root: ParentNode = document,
+): RendererForkContractInspection {
+  const annotatedResponses = [
+    ...root.querySelectorAll<HTMLElement>(`[${RESPONSE_CONVERSATION_ATTRIBUTE}]`),
+  ];
+  const candidateButtons = annotatedResponses.flatMap((annotation) => [
+    ...annotation.querySelectorAll<HTMLButtonElement>("button"),
+  ]);
+  return {
+    annotatedResponseCount: annotatedResponses.length,
+    candidateButtonCount: candidateButtons.length,
+    verifiedButtonCount: candidateButtons.filter(
+      (button) => rendererForkTargetFromButton(button) !== null,
+    ).length,
+  };
+}
+
+class BrowserRendererForkDom implements RendererForkDom {
+  readonly #replayed = new WeakSet<HTMLButtonElement>();
+
+  listen(onFork: (target: RendererForkTarget) => boolean): () => void {
+    const listener = (event: MouseEvent): void => {
+      const origin =
+        event.target instanceof Element
+          ? event.target
+          : event.target instanceof Node
+            ? event.target.parentElement
+            : null;
+      const button = origin?.closest<HTMLButtonElement>("button");
+      if (!button) return;
+      if (this.#replayed.delete(button)) return;
+      const target = rendererForkTargetFromButton(button);
+      if (!target || !onFork(target)) return;
+      event.preventDefault();
+      event.stopImmediatePropagation();
+    };
+    document.addEventListener("click", listener, true);
+    return () => document.removeEventListener("click", listener, true);
+  }
+
+  replay(target: RendererForkTarget): void {
+    if (!(target.control instanceof HTMLButtonElement) || !target.control.isConnected) return;
+    this.#replayed.add(target.control);
+    target.control.click();
+  }
+
+  openThread(threadId: HostThreadId): Promise<void> {
+    return openRendererThread(threadId);
+  }
+}
+
+export function installRendererForkControl(options: {
+  getClient(): RendererModelClient | null;
+  dom?: RendererForkDom;
+  reportError?(error: unknown): void;
+}): RendererForkControl {
+  const dom = options.dom ?? new BrowserRendererForkDom();
+  const pending = new Set<string>();
+  let disposed = false;
+  const stop = dom.listen((target) => {
+    if (disposed) return false;
+    const client = options.getClient();
+    if (!client) return false;
+    const key = `${target.threadId}\u0000${target.turnId}`;
+    if (pending.has(key)) return true;
+    pending.add(key);
+    void client
+      .inspectThread({ threadId: target.threadId })
+      .then(async (inspection) => {
+        if (disposed) return;
+        // Project Threads must retain Desktop's native destination/worktree flow.
+        // forkAcrossCwd validates the chosen destination at Host; it must not bypass that UI.
+        if (
+          inspection.owner === "codex" ||
+          !inspection.history.fork ||
+          !target.isProjectlessConversation
+        ) {
+          dom.replay(target);
+          return;
+        }
+        const result = await client.forkThread({
+          threadId: target.threadId,
+          lastTurnId: target.turnId,
+        });
+        if (!disposed) await dom.openThread(result.threadId);
+      })
+      .catch((error: unknown) => options.reportError?.(error))
+      .finally(() => pending.delete(key));
+    return true;
+  });
+
+  return {
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      stop();
+      pending.clear();
+    },
+  };
+}

package/src/native-ui/renderer-extension/src/renderer-harness-command-claim.ts

@@ -0,0 +1,64 @@
+import type { HarnessCommandDescriptor } from "@codexhost/shared-contracts";
+
+function inputEvent(editor: HTMLElement, text: string): Event {
+  const view = editor.ownerDocument.defaultView;
+  return view?.InputEvent
+    ? new view.InputEvent("input", {
+        bubbles: true,
+        composed: true,
+        data: text,
+        inputType: "insertText",
+      })
+    : new (view?.Event ?? Event)("input", { bubbles: true, composed: true });
+}
+
+function prependTextarea(editor: HTMLElement, prefix: string): boolean {
+  const view = editor.ownerDocument.defaultView;
+  if (!view || !(editor instanceof view.HTMLTextAreaElement)) return false;
+  const setter = Object.getOwnPropertyDescriptor(view.HTMLTextAreaElement.prototype, "value")?.set;
+  if (!setter) return false;
+  const start = editor.selectionStart;
+  const end = editor.selectionEnd;
+  setter.call(editor, prefix + editor.value);
+  editor.dispatchEvent(inputEvent(editor, prefix));
+  editor.focus({ preventScroll: true });
+  if (start !== null && end !== null) {
+    editor.setSelectionRange(start + prefix.length, end + prefix.length);
+  }
+  return true;
+}
+
+function prependContentEditable(editor: HTMLElement, prefix: string): boolean {
+  if (editor.getAttribute("contenteditable") !== "true") return false;
+  const document = editor.ownerDocument;
+  const selection = document.getSelection();
+  if (!selection || typeof document.execCommand !== "function") return false;
+  const range = document.createRange();
+  range.selectNodeContents(editor);
+  range.collapse(true);
+  editor.focus({ preventScroll: true });
+  selection.removeAllRanges();
+  selection.addRange(range);
+  return document.execCommand("insertText", false, prefix);
+}
+
+function prependEditor(editor: HTMLElement, prefix: string): boolean {
+  return prependTextarea(editor, prefix) || prependContentEditable(editor, prefix);
+}
+
+// Clicking compact always uses the native default; typed instructions remain supported.
+export function rendererHarnessCommandExecutesDirectly(command: HarnessCommandDescriptor): boolean {
+  return command.invocation === "/compact" || command.argumentMode === "none";
+}
+
+export function routeRendererHarnessCommandSelection(
+  editor: HTMLElement | null,
+  command: HarnessCommandDescriptor,
+  execute: () => void,
+): boolean {
+  if (rendererHarnessCommandExecutesDirectly(command)) {
+    execute();
+    return true;
+  }
+  return editor !== null && prependEditor(editor, `${command.invocation} `);
+}