harness-mix 0.1.0

package/src/native-ui/desktop-control/src/renderer-dom.ts

@@ -0,0 +1,144 @@
+export interface RendererDomNodeSummary {
+  nodeName: string;
+  attributeNames: string[];
+  reasons: string[];
+  ancestorNames: string[];
+}
+
+export interface RendererShadowRootSummary {
+  shadowRootType: "open";
+  childNodeCount: number;
+}
+
+export interface RendererDomInspection {
+  totalNodes: number;
+  nodeNameCounts: Record<string, number>;
+  shadowRoots: RendererShadowRootSummary[];
+  editorCandidates: RendererDomNodeSummary[];
+  sendButtonCandidates: RendererDomNodeSummary[];
+}
+
+interface RendererRuntimeClient {
+  evaluate<T>(expression: string): Promise<T>;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function stringArray(value: unknown, field: string): string[] {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throw new Error(`Renderer DOM inspection '${field}' must be a text array`);
+  }
+  return [...value];
+}
+
+function nodeSummary(value: unknown): RendererDomNodeSummary {
+  if (!isRecord(value) || typeof value.nodeName !== "string") {
+    throw new Error("Renderer DOM inspection candidate must be an object");
+  }
+  return {
+    nodeName: value.nodeName,
+    attributeNames: stringArray(value.attributeNames, "attributeNames"),
+    reasons: stringArray(value.reasons, "reasons"),
+    ancestorNames: stringArray(value.ancestorNames, "ancestorNames"),
+  };
+}
+
+export function validateRendererDomInspection(value: unknown): RendererDomInspection {
+  if (
+    !isRecord(value) ||
+    !Number.isInteger(value.totalNodes) ||
+    !isRecord(value.nodeNameCounts) ||
+    !Array.isArray(value.shadowRoots) ||
+    !Array.isArray(value.editorCandidates) ||
+    !Array.isArray(value.sendButtonCandidates)
+  ) {
+    throw new Error("Renderer DOM inspection returned an invalid result");
+  }
+  const nodeNameCounts: Record<string, number> = {};
+  for (const [name, count] of Object.entries(value.nodeNameCounts)) {
+    if (!Number.isInteger(count)) {
+      throw new Error("Renderer DOM inspection node counts must be integers");
+    }
+    nodeNameCounts[name] = count as number;
+  }
+  const shadowRoots = value.shadowRoots.map((shadowRoot) => {
+    if (
+      !isRecord(shadowRoot) ||
+      shadowRoot.shadowRootType !== "open" ||
+      !Number.isInteger(shadowRoot.childNodeCount)
+    ) {
+      throw new Error("Renderer DOM inspection returned an invalid shadow root");
+    }
+    return {
+      shadowRootType: "open" as const,
+      childNodeCount: shadowRoot.childNodeCount as number,
+    };
+  });
+  return {
+    totalNodes: value.totalNodes as number,
+    nodeNameCounts,
+    shadowRoots,
+    editorCandidates: value.editorCandidates.map(nodeSummary),
+    sendButtonCandidates: value.sendButtonCandidates.map(nodeSummary),
+  };
+}
+
+const rendererStructureExpression = `(() => {
+  const result = {
+    totalNodes: 0,
+    nodeNameCounts: {},
+    shadowRoots: [],
+    editorCandidates: [],
+    sendButtonCandidates: [],
+  };
+  const summarize = (element, reasons, ancestors) => ({
+    nodeName: element.nodeName.toLowerCase(),
+    attributeNames: element.getAttributeNames().sort(),
+    reasons,
+    ancestorNames: ancestors.slice(-8),
+  });
+  const visit = (node, ancestors) => {
+    result.totalNodes += 1;
+    const nodeName = node.nodeName.toLowerCase();
+    result.nodeNameCounts[nodeName] = (result.nodeNameCounts[nodeName] ?? 0) + 1;
+    if (node.nodeType !== Node.ELEMENT_NODE) return;
+    const element = node;
+    const editorReasons = [];
+    if (nodeName === 'textarea') editorReasons.push('textarea');
+    if (nodeName === 'input' && element.getAttribute('type') !== 'hidden') editorReasons.push('input');
+    if (element.hasAttribute('contenteditable')) editorReasons.push('contenteditable');
+    if (element.getAttribute('role') === 'textbox') editorReasons.push('role=textbox');
+    for (const attribute of ['data-lexical-editor', 'data-slate-editor', 'data-placeholder']) {
+      if (element.hasAttribute(attribute)) editorReasons.push(attribute);
+    }
+    if (editorReasons.length > 0) {
+      result.editorCandidates.push(summarize(element, editorReasons, ancestors));
+    }
+    if (nodeName === 'button' && element.getAttribute('type') === 'submit') {
+      result.sendButtonCandidates.push(summarize(element, ['type=submit'], ancestors));
+    }
+    const nextAncestors = [...ancestors, nodeName];
+    for (const child of element.children) visit(child, nextAncestors);
+    if (element.shadowRoot) {
+      result.shadowRoots.push({
+        shadowRootType: 'open',
+        childNodeCount: element.shadowRoot.childElementCount,
+      });
+      for (const child of element.shadowRoot.children) visit(child, nextAncestors);
+    }
+    if (nodeName === 'template' && element.content) {
+      for (const child of element.content.children) visit(child, nextAncestors);
+    }
+  };
+  visit(document.documentElement, []);
+  return result;
+})()`;
+
+export async function inspectRendererDom(
+  client: RendererRuntimeClient,
+): Promise<RendererDomInspection> {
+  const inspection = await client.evaluate<unknown>(rendererStructureExpression);
+  return validateRendererDomInspection(inspection);
+}

package/src/native-ui/desktop-control/src/renderer-draft-prewarm-policy.ts

@@ -0,0 +1,209 @@
+import type { CdpClient } from "./cdp-client.js";
+import {
+  installDraftPrewarmPolicyBridge,
+  installDraftPrewarmPolicyInRenderer,
+} from "./renderer-draft-prewarm-runtime.js";
+
+interface InspectorEvaluator {
+  evaluate<T>(expression: string): Promise<T>;
+}
+
+export interface RendererDraftPrewarmPolicyStatus {
+  state: "ready";
+  reason: "owned-request-bridge";
+}
+
+export interface RendererRequestManagerCandidate<Manager = object, RequestClient = object> {
+  manager: Manager;
+  requestClient: RequestClient;
+  hostId: unknown;
+  prewarmedThreadManager: unknown;
+}
+
+export function selectRendererRequestManager<Manager, RequestClient>(
+  candidates: readonly RendererRequestManagerCandidate<Manager, RequestClient>[],
+  activeHostIds: readonly unknown[],
+): RendererRequestManagerCandidate<Manager, RequestClient> | null {
+  const unique = new Map<Manager, RendererRequestManagerCandidate<Manager, RequestClient>>();
+  for (const candidate of candidates) unique.set(candidate.manager, candidate);
+
+  const hosts = new Set(
+    activeHostIds.filter((value): value is string => typeof value === "string" && value.length > 0),
+  );
+  if (hosts.size > 1) return null;
+
+  const activeHostId = hosts.values().next().value as string | undefined;
+  const eligible = [...unique.values()].filter(
+    (candidate) => activeHostId === undefined || candidate.hostId === activeHostId,
+  );
+  return eligible.length === 1 ? (eligible[0] ?? null) : null;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+const FIND_REQUEST_MANAGER_EXPRESSION = `(() => {
+  const editors = [...document.querySelectorAll(
+    '[data-codex-composer], [contenteditable="true"][role="textbox"]',
+  )];
+  if (editors.length !== 1) {
+    return { candidateCount: 0, hostId: null, sendRequest: null };
+  }
+  let element = editors[0];
+  let fiber = null;
+  while (element != null && fiber == null) {
+    const key = Object.getOwnPropertyNames(element).find((name) =>
+      name.startsWith('__reactFiber$'),
+    );
+    if (key != null) fiber = element[key];
+    element = element.parentElement;
+  }
+  const managers = new Set();
+  const activeHostIds = new Set();
+  for (let depth = 0; fiber != null && depth < 200; depth += 1, fiber = fiber.return) {
+    const props = fiber.memoizedProps;
+    if (props != null && typeof props === 'object') {
+      for (const name of ['executionTargetHostId', 'permissionsHostId']) {
+        const value = props[name];
+        if (typeof value === 'string' && value.length > 0) activeHostIds.add(value);
+      }
+    }
+    let hook = fiber.memoizedState;
+    for (let index = 0; hook != null && index < 120; index += 1, hook = hook.next) {
+      const value = hook.memoizedState;
+      if (
+        value != null &&
+        typeof value === 'object' &&
+        value.requestClient != null &&
+        typeof value.requestClient.prewarmThreadStart === 'function' &&
+        typeof value.requestClient.sendRequest === 'function' &&
+        typeof value.requestClient.enqueueRequest === 'function' &&
+        typeof value.prewarmedThreadManager?.discardAllPrewarmedThreads === 'function' &&
+        typeof value.sendRequest === 'function'
+      ) {
+        managers.add(value);
+      }
+    }
+  }
+  const candidates = [...managers].map((manager) => {
+    const requestClient =
+      typeof manager.requestClient?.sendRequest === 'function' &&
+      typeof manager.requestClient?.prewarmThreadStart === 'function' &&
+      typeof manager.requestClient?.enqueueRequest === 'function'
+        ? manager.requestClient
+        : manager;
+    return {
+      manager,
+      requestClient,
+      hostId: manager?.getHostId?.() ?? requestClient?.hostId ?? null,
+      prewarmedThreadManager: manager?.prewarmedThreadManager ?? null,
+    };
+  });
+  const selected = (${selectRendererRequestManager.toString()})(candidates, [...activeHostIds]);
+  return {
+    candidateCount: selected == null ? candidates.length : 1,
+    hostId: selected?.hostId ?? null,
+    manager: selected?.manager ?? null,
+    requestClient: selected?.requestClient ?? null,
+    prewarmedThreadManager: selected?.prewarmedThreadManager ?? null,
+  };
+})()`;
+
+const INSTALL_RENDERER_POLICY_FUNCTION = `function(requestClient, hostId, prewarmedThreadManager) {
+  return (${installDraftPrewarmPolicyBridge.toString()})(
+    this,
+    requestClient,
+    hostId,
+    window,
+    prewarmedThreadManager,
+  );
+}`;
+const REQUEST_MANAGER_WAIT_TIMEOUT_MS = 60_000;
+const REQUEST_MANAGER_POLL_INTERVAL_MS = 25;
+
+function directRendererInstaller(): string {
+  return `(async () => {
+    const selected = ${FIND_REQUEST_MANAGER_EXPRESSION};
+    if (
+      selected.candidateCount !== 1 ||
+      typeof selected.hostId !== 'string' ||
+      selected.hostId.length === 0 ||
+      selected.manager == null ||
+      selected.requestClient == null
+    ) {
+      throw new Error('Renderer request manager is ambiguous');
+    }
+    if (selected.prewarmedThreadManager == null) {
+      throw new Error('Renderer prewarmed Thread manager is unavailable');
+    }
+    return (${installDraftPrewarmPolicyBridge.toString()})(
+      selected.manager,
+      selected.requestClient,
+      selected.hostId,
+      window,
+      selected.prewarmedThreadManager,
+    );
+  })()`;
+}
+
+function mainProcessInstaller(rendererWebContentsId: number): string {
+  return `async function () {
+    const mainModule = process.mainModule;
+    const electron = mainModule != null && typeof mainModule.require === 'function'
+      ? mainModule.require('electron')
+      : process.getBuiltinModule('module').createRequire(process.execPath)('electron');
+    const contents = electron.webContents.fromId(${rendererWebContentsId});
+    return (${installDraftPrewarmPolicyInRenderer.toString()})(
+      contents,
+      ${JSON.stringify(FIND_REQUEST_MANAGER_EXPRESSION)},
+      ${JSON.stringify(INSTALL_RENDERER_POLICY_FUNCTION)}
+    );
+  }`;
+}
+
+async function waitForDraftPrewarmPolicy(
+  evaluate: (expression: string) => Promise<unknown>,
+  expression: string,
+): Promise<RendererDraftPrewarmPolicyStatus> {
+  const deadline = Date.now() + REQUEST_MANAGER_WAIT_TIMEOUT_MS;
+  while (true) {
+    try {
+      const value = await evaluate(expression);
+      if (!isRecord(value) || value.state !== "ready" || value.reason !== "owned-request-bridge") {
+        throw new Error("Renderer draft prewarm policy returned an invalid status");
+      }
+      return value as unknown as RendererDraftPrewarmPolicyStatus;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const remaining = deadline - Date.now();
+      if (!message.includes("Renderer request manager is ambiguous") || remaining <= 0) throw error;
+      await new Promise<void>((resolve) => {
+        setTimeout(resolve, Math.min(REQUEST_MANAGER_POLL_INTERVAL_MS, remaining));
+      });
+    }
+  }
+}
+
+export function installRendererDraftPrewarmPolicyDirect(
+  renderer: Pick<CdpClient, "evaluate"> | InspectorEvaluator,
+): Promise<RendererDraftPrewarmPolicyStatus> {
+  return waitForDraftPrewarmPolicy(
+    (expression) => renderer.evaluate<unknown>(expression),
+    directRendererInstaller(),
+  );
+}
+
+export async function installRendererDraftPrewarmPolicy(
+  inspector: Pick<CdpClient, "evaluate"> | InspectorEvaluator,
+  rendererWebContentsId: number,
+): Promise<RendererDraftPrewarmPolicyStatus> {
+  if (!Number.isInteger(rendererWebContentsId) || rendererWebContentsId <= 0) {
+    throw new Error("Renderer webContents ID must be a positive integer");
+  }
+  const installer = mainProcessInstaller(rendererWebContentsId);
+  return waitForDraftPrewarmPolicy(
+    (expression) => inspector.evaluate<unknown>(expression),
+    `(${installer})()`,
+  );
+}