imprint-mcp 0.6.0 → 0.6.2

package/src/imprint/mcp-live-verifier-server.ts

@@ -0,0 +1,359 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join as pathJoin } from 'node:path';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  type CallToolResult,
+  ListToolsRequestSchema,
+  type Tool,
+} from '@modelcontextprotocol/sdk/types.js';
+import {
+  type LiveIntegrationEvidence,
+  runCapturedIntegrationCase,
+} from './compile-verification.ts';
+import {
+  LIVE_VERIFICATION_EVIDENCE_FILE,
+  LiveVerificationReportSchema,
+  appendLiveVerifierLog,
+  assertReportCoversWorkflowParameters,
+  effectiveParamsForEvidence,
+  hasSuiteReceiptForSession,
+  persistLiveVerificationEvidence,
+  prepareLiveVerificationBackend,
+  readPersistedLiveVerificationEvidence,
+  runLiveIntegrationSuite,
+} from './live-verifier.ts';
+import { loadCredentialStore } from './runtime.ts';
+import { buildZodValidator } from './tool-loader.ts';
+import { WorkflowSchema } from './types.ts';
+
+export function joinBackendPreparation<T>(
+  state: { current?: { promise: Promise<T>; forceReprobe: boolean } },
+  forceReprobe: boolean,
+  start: () => Promise<T>,
+): { promise: Promise<T>; joined: boolean } {
+  if (state.current && (!forceReprobe || state.current.forceReprobe)) {
+    return { promise: state.current.promise, joined: true };
+  }
+
+  // A forced reprobe must not be satisfied by an ordinary preparation that
+  // was already in flight. Queue it behind that preparation so both calls do
+  // not race while updating the same backend cache. Further callers can join
+  // the queued forced preparation.
+  const preceding = state.current?.promise;
+  const started = preceding ? preceding.then(start, start) : start();
+  const promise = started.finally(() => {
+    if (state.current?.promise === promise) state.current = undefined;
+  });
+  state.current = { promise, forceReprobe };
+  return { promise, joined: false };
+}
+
+const RUN_TOOL: Tool = {
+  name: 'run_live_integration_test',
+  description:
+    'Run a targeted live call for a specific unresolved semantic question. Repeated parameters are allowed when the reason explains why.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      params: { type: 'object', additionalProperties: true },
+      reason: { type: 'string' },
+    },
+    required: ['params', 'reason'],
+  },
+};
+
+const PREPARE_BACKEND_TOOL: Tool = {
+  name: 'prepare_live_backend',
+  description:
+    'Reuse the preferred backend and probe only when no valid preference exists. Set forceReprobe only after a transport, network, or browser-infrastructure failure from that backend; never reprobe for empty, incorrect, or otherwise semantic output failures.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      params: { type: 'object', additionalProperties: true },
+      reason: { type: 'string' },
+      forceReprobe: { type: 'boolean' },
+    },
+    required: ['params', 'reason'],
+  },
+};
+
+const RUN_SUITE_TOOL: Tool = {
+  name: 'run_live_integration_suite',
+  description:
+    'Run the compiler-proposed final integration suite. A justified rerun is allowed after failure, timeout, or backend reprobe.',
+  inputSchema: {
+    type: 'object',
+    properties: { reason: { type: 'string' } },
+    additionalProperties: false,
+  },
+};
+
+const SUBMIT_TOOL: Tool = {
+  name: 'submit_verification_report',
+  description: 'Submit the final structured semantic verification report exactly once.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      status: {
+        type: 'string',
+        enum: ['approved', 'approved_with_gaps', 'changes_required', 'inconclusive'],
+      },
+      summary: { type: 'string' },
+      baseline: {
+        type: 'object',
+        properties: {
+          verdict: {
+            type: 'string',
+            enum: ['semantically_correct', 'tool_broken', 'bad_parameters', 'infrastructure'],
+          },
+          reason: { type: 'string' },
+        },
+        required: ['verdict', 'reason'],
+      },
+      parameters: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            name: { type: 'string' },
+            verdict: {
+              type: 'string',
+              enum: ['works', 'no_op', 'broken', 'untestable'],
+            },
+            reason: { type: 'string' },
+          },
+          required: ['name', 'verdict', 'reason'],
+          additionalProperties: false,
+        },
+      },
+      issues: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            summary: { type: 'string' },
+            expected: { type: 'string' },
+            observed: { type: 'string' },
+            suggestedFix: { type: 'string' },
+          },
+          required: ['summary', 'expected', 'observed', 'suggestedFix'],
+          additionalProperties: false,
+        },
+      },
+      gaps: { type: 'array', items: { type: 'string' } },
+    },
+    required: ['status', 'summary', 'baseline', 'parameters', 'issues', 'gaps'],
+  },
+};
+
+export async function runLiveVerifierMcpServer(opts: {
+  workflowPath: string;
+  reportPath: string;
+  sessionLabel: string;
+  logPath?: string;
+  attempt?: number;
+}): Promise<void> {
+  const workflow = WorkflowSchema.parse(JSON.parse(readFileSync(opts.workflowPath, 'utf8')));
+  const validator = buildZodValidator(workflow.parameters);
+  const credentials = (await loadCredentialStore(workflow.site)) ?? undefined;
+  let submitted = false;
+  const backendPreparation: {
+    current?: {
+      promise: Promise<Awaited<ReturnType<typeof prepareLiveVerificationBackend>>>;
+      forceReprobe: boolean;
+    };
+  } = {};
+  const evidencePath = pathJoin(dirname(opts.reportPath), LIVE_VERIFICATION_EVIDENCE_FILE);
+  let targetedCallSequence = readPersistedLiveVerificationEvidence(evidencePath).reduce(
+    (highest, item) => {
+      const match = /^targeted-call-(\d+)$/.exec(item.label);
+      return match ? Math.max(highest, Number(match[1])) : highest;
+    },
+    0,
+  );
+  const hasSuiteReceipt = (): boolean => hasSuiteReceiptForSession(evidencePath, opts.sessionLabel);
+
+  const server = new Server(
+    { name: 'imprint-live-verifier', version: '1.0.0' },
+    { capabilities: { tools: {} } },
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [PREPARE_BACKEND_TOOL, RUN_SUITE_TOOL, RUN_TOOL, SUBMIT_TOOL],
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request): Promise<CallToolResult> => {
+    if (request.params.name === 'prepare_live_backend') {
+      const input = request.params.arguments as {
+        params?: unknown;
+        reason?: unknown;
+        forceReprobe?: unknown;
+      };
+      if (typeof input.reason !== 'string' || !input.reason.trim()) {
+        return errorResult('reason must explain the backend preparation or reprobe');
+      }
+      const parsed = validator.safeParse(input.params ?? {});
+      if (!parsed.success) return errorResult(`invalid tool params: ${parsed.error.message}`);
+      try {
+        const forceReprobe = input.forceReprobe === true;
+        const preparation = joinBackendPreparation(backendPreparation, forceReprobe, () =>
+          prepareLiveVerificationBackend({
+            workflowPath: opts.workflowPath,
+            params: parsed.data as Record<string, string | number | boolean>,
+            reason: input.reason as string,
+            forceReprobe,
+            logPath: opts.logPath,
+            attempt: opts.attempt,
+          }),
+        );
+        if (preparation.joined) {
+          appendLiveVerifierLog(opts.logPath, {
+            type: 'backend.prepare.joined',
+            attempt: opts.attempt,
+            reason: input.reason,
+            forceReprobe: input.forceReprobe === true,
+          });
+        }
+        const result = await preparation.promise;
+        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+      } catch (error) {
+        return errorResult(error instanceof Error ? error.message : String(error));
+      }
+    }
+    if (request.params.name === 'run_live_integration_suite') {
+      const input = request.params.arguments as { reason?: unknown };
+      try {
+        const suite = await runLiveIntegrationSuite({
+          toolDir: dirname(opts.workflowPath),
+          logPath: opts.logPath,
+          attempt: opts.attempt,
+          reason: typeof input.reason === 'string' ? input.reason : undefined,
+          sessionLabel: opts.sessionLabel,
+        });
+        return { content: [{ type: 'text', text: JSON.stringify(suite) }] };
+      } catch (error) {
+        return errorResult(error instanceof Error ? error.message : String(error));
+      }
+    }
+    if (request.params.name === 'run_live_integration_test') {
+      if (!hasSuiteReceipt())
+        return errorResult('run the final integration suite before a targeted call');
+      const input = request.params.arguments as { params?: unknown; reason?: unknown };
+      if (typeof input.reason !== 'string' || !input.reason.trim()) {
+        return errorResult('reason must explain the unresolved semantic question');
+      }
+      const parsed = validator.safeParse(input.params ?? {});
+      if (!parsed.success) return errorResult(`invalid tool params: ${parsed.error.message}`);
+      const label = `targeted-call-${++targetedCallSequence}`;
+      const startedAt = Date.now();
+      appendLiveVerifierLog(opts.logPath, {
+        type: 'targeted-call.started',
+        attempt: opts.attempt,
+        label,
+        reason: input.reason,
+        params: parsed.data,
+      });
+      let run: Awaited<ReturnType<typeof runCapturedIntegrationCase>>;
+      try {
+        run = await runCapturedIntegrationCase({
+          caseName: label,
+          workflowPath: opts.workflowPath,
+          params: parsed.data as Record<string, string | number | boolean>,
+          credentials,
+          preferredOnlyBackend: true,
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        appendLiveVerifierLog(opts.logPath, {
+          type: 'targeted-call.failed',
+          attempt: opts.attempt,
+          label,
+          error: message,
+        });
+        return errorResult(message);
+      }
+      const supplemental: LiveIntegrationEvidence = {
+        schemaVersion: 1 as const,
+        kind: 'call',
+        label,
+        caseName: label,
+        toolName: workflow.toolName,
+        requestedParams: parsed.data as Record<string, string | number | boolean>,
+        effectiveParams: effectiveParamsForEvidence(
+          workflow.parameters,
+          parsed.data as Record<string, string | number | boolean>,
+        ),
+        result: run.result,
+        usedBackend: run.usedBackend,
+        attempts: run.attempts,
+        durationMs: Date.now() - startedAt,
+      };
+      persistLiveVerificationEvidence(evidencePath, [supplemental]);
+      appendLiveVerifierLog(opts.logPath, {
+        type: 'targeted-call.completed',
+        attempt: opts.attempt,
+        record: supplemental,
+      });
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify({
+              label: supplemental.label,
+              toolName: workflow.toolName,
+              requestedParams: parsed.data,
+              result: run.result,
+              usedBackend: run.usedBackend,
+              attempts: run.attempts,
+            }),
+          },
+        ],
+      };
+    }
+    if (request.params.name === 'submit_verification_report') {
+      if (submitted) return errorResult('verification report was already submitted');
+      const parsed = LiveVerificationReportSchema.safeParse(request.params.arguments);
+      if (!parsed.success)
+        return errorResult(`invalid verification report: ${parsed.error.message}`);
+      if (!hasSuiteReceipt()) {
+        return errorResult('run the final integration suite before submitting');
+      }
+      try {
+        assertReportCoversWorkflowParameters(parsed.data, workflow.parameters);
+      } catch (error) {
+        return errorResult(error instanceof Error ? error.message : String(error));
+      }
+      submitted = true;
+      appendLiveVerifierLog(opts.logPath, {
+        type: 'report.submitted',
+        attempt: opts.attempt,
+        report: parsed.data,
+      });
+      writeFileSync(opts.reportPath, `${JSON.stringify(parsed.data, null, 2)}\n`, {
+        encoding: 'utf8',
+        mode: 0o600,
+      });
+      return {
+        content: [{ type: 'text', text: 'Report accepted. End the verification session now.' }],
+      };
+    }
+    return errorResult(`unknown tool: ${request.params.name}`);
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+
+  // Server.connect() resolves after initialization; it does not own the
+  // process lifetime. Keep stdio alive until the verifier disconnects, just
+  // like the compile MCP server does, or Codex can lose the server during its
+  // initialize handshake.
+  await new Promise<void>((resolve) => {
+    const close = (): void => resolve();
+    transport.onclose = close;
+    process.once('SIGINT', close);
+    process.once('SIGTERM', close);
+  });
+}
+
+function errorResult(message: string): CallToolResult {
+  return { isError: true, content: [{ type: 'text', text: message }] };
+}

package/src/imprint/mcp-server.ts

@@ -4,6 +4,7 @@
  * See docs/getting-started.md for Claude Desktop / mcp-inspector wire-up.
  */
 
+import { randomUUID } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { type IncomingMessage, type ServerResponse, createServer } from 'node:http';
 import { resolve as pathResolve } from 'node:path';
@@ -30,7 +31,7 @@ import {
   buildZodValidator,
   discoverTools,
 } from './tool-loader.ts';
-import type { ConcreteBackend, ToolResult, WorkflowParameter } from './types.ts';
+import type { ConcreteBackend, ToolResult, Workflow, WorkflowParameter } from './types.ts';
 import { VERSION } from './version.ts';
 
 interface RunMcpServerOptions {
@@ -60,19 +61,32 @@ interface ResolvedTool extends DiscoveredTool {
 /** Tool description shown to MCP clients. Includes the operator's
  *  recorded narration when present — surprisingly load-bearing for the
  *  LLM picking the right tool. */
-function buildToolDescription(w: ResolvedTool['workflow']): string {
+export function buildToolDescription(w: ResolvedTool['workflow']): string {
   const base = w.intent.description;
   const said = w.intent.userSaid?.trim();
-  return said ? `${base}\n\nRecording context: "${said}"` : base;
+  const context = said ? `${base}\n\nRecording context: "${said}"` : base;
+  if (!w.limitations?.length) return context;
+  const limitations = w.limitations
+    .map((entry) => {
+      const omitted = entry.omittedParameters?.length
+        ? ` Omitted inputs: ${entry.omittedParameters.join(', ')}.`
+        : '';
+      return `- ${entry.feature}: ${entry.reason}${omitted}`;
+    })
+    .join('\n');
+  return `${context}\n\nKnown limitations:\n${limitations}`;
 }
 
 /** MCP advertises tool input as JSON Schema; build it directly from
  *  workflow parameters rather than going through Zod. */
 export function buildJsonSchema(
   parameters: WorkflowParameter[],
-  opts?: { includeTwoFactorContext?: boolean },
+  opts?: { authConfig?: Workflow['authConfig'] },
 ): Tool['inputSchema'] {
-  const properties: Record<string, { type: string; description: string }> = {};
+  const properties: Record<
+    string,
+    { type: string; description: string; enum?: Array<string | number | boolean> }
+  > = {};
   const required: string[] = [];
   for (const p of parameters) {
     // Producer-sourced params: tell the orchestrating LLM where to mint/derive
@@ -81,18 +95,24 @@ export function buildJsonSchema(
     const description = p.sourcedFrom
       ? `${p.description} Obtain this value from the \`${p.sourcedFrom.tool}\` tool's \`${p.sourcedFrom.field}\` output — call \`${p.sourcedFrom.tool}\` first and reuse the value across calls (no need to re-fetch each time).`
       : p.description;
-    properties[p.name] = { type: p.type, description };
-    if (p.default === undefined) required.push(p.name);
+    const property: { type: string; description: string; enum?: Array<string | number | boolean> } =
+      {
+        type: p.type,
+        description,
+      };
+    if (p.choices?.length) property.enum = p.choices;
+    properties[p.name] = property;
+    if (p.default === undefined && !opts?.authConfig) required.push(p.name);
   }
-  // Auth 2FA bridge (stateless): on the second (submit_otp) call the caller
-  // passes back the `twoFactorContext` object echoed verbatim in the prior
-  // AWAITING_2FA result, so a login token captured on the first call is
-  // available to the completion request. Never required (absent on initiate).
-  if (opts?.includeTwoFactorContext) {
-    properties.twoFactorContext = {
-      type: 'object',
-      description:
-        'Only for the submit_otp call: pass back the `twoFactorContext` object returned verbatim in the previous AWAITING_2FA response.',
+  if (opts?.authConfig) {
+    properties.action = {
+      type: 'string',
+      description: `Auth action to run. Defaults to ${JSON.stringify(opts.authConfig.entry)}.`,
+      enum: Object.keys(opts.authConfig.actions),
+    };
+    properties.continuation = {
+      type: 'string',
+      description: 'One-use opaque token returned by the previous auth action.',
     };
   }
   return {
@@ -104,6 +124,33 @@ export function buildJsonSchema(
 
 const log = createLog('mcp');
 
+interface StoredAuthContinuation {
+  toolName: string;
+  nextAction?: string;
+  state: Record<string, unknown>;
+}
+
+export class AuthContinuationStore {
+  private readonly values = new Map<string, StoredAuthContinuation>();
+
+  issue(value: StoredAuthContinuation): string {
+    const token = randomUUID();
+    this.values.set(token, value);
+    return token;
+  }
+
+  consume(token: string, toolName: string, action: string): Record<string, unknown> | undefined {
+    const value = this.values.get(token);
+    this.values.delete(token);
+    if (!value || value.toolName !== toolName || value.nextAction !== action) return undefined;
+    return value.state;
+  }
+
+  clear(): void {
+    this.values.clear();
+  }
+}
+
 export async function runSerializedBySite<T>(
   queues: Map<string, Promise<void>>,
   site: string,
@@ -141,12 +188,20 @@ function buildServer(
     {
       capabilities: { tools: {} },
       instructions:
-        'Imprint runs deterministic workflows captured from real browser sessions. Tools prefer fetch API replay, may use gated fetch-bootstrap only for declared browser-minted state, then cdp-replay (API requests run inside a live trusted Chrome so a protected POST refreshes its anti-bot token between calls) for multi-step state-changing flows, then stealth-fetch for bot-defense state, and playbook only for full DOM interaction. Error codes: AUTH_EXPIRED (401, call authenticate_<site> if available or run `imprint login <site>`); AWAITING_2FA (2FA required — approve push / enter OTP then call again with action=complete); STATE_MISSING (required cookie/state was unavailable or ambiguous); FORBIDDEN (403); RATE_LIMITED (429, back off); BAD_RESPONSE (other 4xx/5xx); NETWORK (fetch failed); UNKNOWN (everything else).',
+        'Imprint runs deterministic workflows captured from real browser sessions. Data tools can escalate through API, browser, and playbook backends. Authenticate tools execute their compiled action program without playbooks. Error codes: AUTH_EXPIRED (401); ACTION_REQUIRED (run nextAction and pass continuation back unchanged); STATE_MISSING; FORBIDDEN; RATE_LIMITED; BAD_RESPONSE; NETWORK; UNKNOWN.',
     },
   );
 
   const validators = new Map(
-    tools.map((t) => [t.workflow.toolName, buildZodValidator(t.workflow.parameters)] as const),
+    tools.map(
+      (t) =>
+        [
+          t.workflow.toolName,
+          buildZodValidator(t.workflow.parameters, {
+            allOptional: t.workflow.toolKind === 'authenticate',
+          }),
+        ] as const,
+    ),
   );
 
   // Per-site stealth-fetch cache so the ~12s bootstrap runs once per site.
@@ -156,6 +211,7 @@ function buildServer(
   // the first successful call so subsequent calls reuse it (~2-5s vs ~33s).
   const cdpPool = new Map<string, CdpBrowserFetch>();
   const cdpIdleTimers = new Map<string, ReturnType<typeof setTimeout>>();
+  const authContinuations = new AuthContinuationStore();
   const CDP_IDLE_TIMEOUT_MS = 5 * 60 * 1000;
 
   // Per-tool memo of the winning backend for THIS server session. After the
@@ -208,16 +264,31 @@ function buildServer(
       string | number | boolean
     >;
 
-    // Auth 2FA bridge (stateless): the validator strips unknown keys, so read the
-    // echoed `twoFactorContext` from the raw arguments and seed it as initialState
-    // so a token captured on the initiate call resolves on this submit_otp call.
     const rawArgs = (req.params.arguments ?? {}) as Record<string, unknown>;
-    const initialState =
-      tool.workflow.toolKind === 'authenticate' &&
-      rawArgs.twoFactorContext &&
-      typeof rawArgs.twoFactorContext === 'object'
-        ? (rawArgs.twoFactorContext as Record<string, unknown>)
-        : undefined;
+    if (tool.workflow.toolKind === 'authenticate' && typeof rawArgs.action === 'string') {
+      args.action = rawArgs.action;
+    }
+    let initialState: Record<string, unknown> | undefined;
+    if (tool.workflow.toolKind === 'authenticate' && rawArgs.continuation !== undefined) {
+      const action = String(args.action ?? tool.workflow.authConfig?.entry ?? '');
+      if (typeof rawArgs.continuation !== 'string') {
+        return {
+          isError: true,
+          content: [{ type: 'text', text: 'Invalid continuation token.' }],
+        };
+      }
+      initialState = authContinuations.consume(
+        rawArgs.continuation,
+        tool.workflow.toolName,
+        action,
+      );
+      if (!initialState) {
+        return {
+          isError: true,
+          content: [{ type: 'text', text: 'Invalid or expired continuation token.' }],
+        };
+      }
+    }
 
     try {
       return await runSerializedBySite(siteExecutionQueues, tool.site, async () => {
@@ -293,7 +364,16 @@ function buildServer(
           cdpIdleTimers.set(tool.site, timer);
         }
         if (!result.ok) {
-          const text = formatToolError(result);
+          const continuationToken =
+            tool.workflow.toolKind === 'authenticate' && result.continuation
+              ? authContinuations.issue({
+                  toolName: tool.workflow.toolName,
+                  nextAction:
+                    result.nextAction ?? String(args.action ?? tool.workflow.authConfig?.entry),
+                  state: result.continuation,
+                })
+              : undefined;
+          const text = formatToolError(result, continuationToken);
           return {
             isError: true,
             content: [{ type: 'text', text: `${text}\n(backend: ${usedBackend})` }],
@@ -331,12 +411,16 @@ function buildServer(
     for (const timer of cdpIdleTimers.values()) clearTimeout(timer);
     cdpIdleTimers.clear();
     winnerCache.clear();
+    authContinuations.clear();
   }
 
   return { server, closeCdpPool };
 }
 
-function formatToolError(result: Extract<ToolResult, { ok: false }>): string {
+function formatToolError(
+  result: Extract<ToolResult, { ok: false }>,
+  continuationToken?: string,
+): string {
   const lines = [`[${result.error}] ${result.message}`];
   if (result.error === 'STATE_MISSING' && result.missing?.length) {
     for (const item of result.missing) {
@@ -345,11 +429,8 @@ function formatToolError(result: Extract<ToolResult, { ok: false }>): string {
       );
     }
   }
-  // Auth 2FA bridge (stateless): echo the captured login context back to the
-  // caller so it can pass it as `twoFactorContext` on the submit_otp call.
-  if (result.error === 'AWAITING_2FA' && result.twoFactorContext) {
-    lines.push(`  twoFactorContext: ${JSON.stringify(result.twoFactorContext)}`);
-  }
+  if (result.nextAction) lines.push(`  nextAction: ${result.nextAction}`);
+  if (continuationToken) lines.push(`  continuation: ${JSON.stringify(continuationToken)}`);
   if (result.remediation) lines.push(`  → ${result.remediation}`);
   return lines.join('\n');
 }
@@ -370,7 +451,7 @@ export async function runMcpServer(opts: RunMcpServerOptions): Promise<void> {
     return {
       ...t,
       inputSchema: buildJsonSchema(t.workflow.parameters, {
-        includeTwoFactorContext: t.workflow.toolKind === 'authenticate',
+        authConfig: t.workflow.toolKind === 'authenticate' ? t.workflow.authConfig : undefined,
       }),
       playbookPath: existsSync(playbookPath) ? playbookPath : undefined,
       preferredOrder: cacheStatus.status === 'ok' ? cacheStatus.cache.preferredOrder : undefined,