@rogatio/cli 6.15.0 → 6.16.0

package/README.md

@@ -45,6 +45,8 @@ rogatio <command> [options]
 | `rogatio runtime <install\|uninstall\|verify>` | Register the native-messaging host with `install` and trust the device-local CA in one **transactional** call; it needs elevated privileges (Linux `sudo`, macOS keychain authorization, Windows Administrator) and rolls back with exit `1` and `trust unsupported: <reasons>` when a capability or elevation is missing. Release users never pass `--extension-id`. That flag is only for development (a local unpacked build without the release key) and for forks. `uninstall` removes the host manifest, the device-local CA files, and the CA trust installation (idempotent). `verify` reports whether manifest, `runtime-host` wrapper, allowed origins, and CA trust are all valid, and fails when `allowed_origins` omits the release ID. Release users never pass `--extension-id` on verify either. |
 | `rogatio runtime host [path]` | Run the consolidated native-messaging host for the project (pair/authorize/body transforms and mock responses over stdio). Normally launched by the browser; run manually only for debugging. `--root <dir>` overrides the confined mock file root. When omitted, a saved device-local root for that project file is used, otherwise the project directory. A stdin project that contains a file mock requires `--root`. |
 
+`rogatio edit` includes **Run checks**. It calls `POST /api/doctor` (CSRF-protected) and shows editor checks plus the same report as `rogatio doctor` for the open file. A provider configured after the page opened is picked up on the next `rogatio edit`.
+
 Global options: `--help, -h` and `--version, -v`. Run `rogatio <command> --help`
 for command-specific usage.
 

package/dist/node/index.js

@@ -23225,9 +23225,9 @@ function generatePacScript(routes, endpoint, options) {
   }
   const checksByKey = /* @__PURE__ */ new Map();
   for (const route of routes) {
-    const check2 = pacCheck(route);
-    if (check2 === null) continue;
-    checksByKey.set(check2.key, check2.line);
+    const check22 = pacCheck(route);
+    if (check22 === null) continue;
+    checksByKey.set(check22.key, check22.line);
   }
   const sorted = [...checksByKey.entries()].sort(
     ([left], [right]) => left.localeCompare(right)
@@ -23325,6 +23325,9 @@ function exactRegistryVersion(value) {
   const match = REGISTRY_VERSION_RE.exec(value);
   return match === null ? null : match[0];
 }
+function exactDoctorVersion(value) {
+  return exactRegistryVersion(value);
+}
 function doctorFixCliUpdate(version) {
   return `npm install -g @rogatio/cli@${version}`;
 }
@@ -24371,13 +24374,13 @@ async function fetchAuthorized(operation, options = {}) {
   const protocol = url.protocol === "https:" ? "https:" : "http:";
   const port = protocol === "https:" ? 443 : 80;
   const timeoutMs = options.operationTimeoutMs ?? RUNTIME_LIMITS.operationTimeoutMs;
-  const combined = combineSignals(
+  const combined2 = combineSignals(
     options.signal,
     Math.max(1, Math.min(timeoutMs, RUNTIME_LIMITS.operationTimeoutMs))
   );
   try {
     const resolver = options.resolver ?? defaultResolver;
-    const resolved = await resolver.lookup(url.hostname, combined.signal);
+    const resolved = await resolver.lookup(url.hostname, combined2.signal);
     const addresses = validateResolvedAddresses(
       resolved,
       RUNTIME_LIMITS.maxDnsAddresses
@@ -24397,12 +24400,12 @@ async function fetchAuthorized(operation, options = {}) {
         method: operation.method,
         headers: { host: url.host, "accept-encoding": "identity" },
         ...protocol === "https:" ? { servername: url.hostname } : {},
-        signal: combined.signal
+        signal: combined2.signal
       });
     } catch {
-      return combined.signal.aborted ? failure("runtime.timeout") : failure("runtime.internal");
+      return combined2.signal.aborted ? failure("runtime.timeout") : failure("runtime.internal");
     }
-    if (combined.signal.aborted) return failure("runtime.timeout");
+    if (combined2.signal.aborted) return failure("runtime.timeout");
     if (response.status >= 300 && response.status <= 399)
       return failure("runtime.redirect-rejected");
     if (responseHeaderBytes(response.headers) > RUNTIME_LIMITS.maxResponseHeaderBytes)
@@ -24414,7 +24417,7 @@ async function fetchAuthorized(operation, options = {}) {
     let total = 0;
     try {
       for await (const chunk of response.body) {
-        if (combined.signal.aborted) return failure("runtime.timeout");
+        if (combined2.signal.aborted) return failure("runtime.timeout");
         const bytes = chunk instanceof Uint8Array ? Uint8Array.from(chunk) : Uint8Array.from(chunk);
         total += bytes.byteLength;
         if (total > RUNTIME_LIMITS.maxResponseBodyBytes)
@@ -24422,7 +24425,7 @@ async function fetchAuthorized(operation, options = {}) {
         chunks.push(bytes);
       }
     } catch {
-      return combined.signal.aborted ? failure("runtime.timeout") : failure("runtime.internal");
+      return combined2.signal.aborted ? failure("runtime.timeout") : failure("runtime.internal");
     }
     const body = new Uint8Array(total);
     let offset = 0;
@@ -24435,9 +24438,9 @@ async function fetchAuthorized(operation, options = {}) {
       value: { status: response.status, headers: response.headers, body }
     };
   } catch {
-    return combined.signal.aborted ? failure("runtime.timeout") : failure("runtime.dns-failed");
+    return combined2.signal.aborted ? failure("runtime.timeout") : failure("runtime.dns-failed");
   } finally {
-    combined.dispose();
+    combined2.dispose();
   }
 }
 function supportedContentType2(value) {
@@ -27003,6 +27006,13 @@ function decodeEnvelopeFrame(buffer) {
 function defaultTrustRoot() {
   return defaultTrustInstallRoot(process.platform);
 }
+function doctorReplyMetadata(report2, cliVersion) {
+  const version = typeof cliVersion === "string" ? exactDoctorVersion(cliVersion) : null;
+  return {
+    report: doctorReportValue(report2),
+    ...version !== null ? { cliVersion: version } : {}
+  };
+}
 function createNativeHost(options) {
   const controller = createNativeRuntimeController({
     preset: options.preset,
@@ -27248,7 +27258,7 @@ function createNativeHost(options) {
             type: "runtime.doctor",
             ...envelope.requestId !== void 0 ? { requestId: envelope.requestId } : {},
             timestamp: Date.now(),
-            metadata: { report: doctorReportValue(doctorReport) }
+            metadata: doctorReplyMetadata(doctorReport, options.cliVersion)
           });
         } catch {
           return encodeEnvelopeFrame({
@@ -27256,7 +27266,10 @@ function createNativeHost(options) {
             type: "runtime.doctor",
             ...envelope.requestId !== void 0 ? { requestId: envelope.requestId } : {},
             timestamp: Date.now(),
-            metadata: { report: doctorReportValue(doctorInterruptedReport()) }
+            metadata: doctorReplyMetadata(
+              doctorInterruptedReport(),
+              options.cliVersion
+            )
           });
         }
       }
@@ -28327,6 +28340,319 @@ async function doctorCommand(args, options = {}) {
 // packages/cli/src/commands/edit.ts
 import { resolve as resolve6 } from "node:path";
 
+// packages/cli/src/editor-doctor.ts
+var EDITOR_CHECK_TITLES = {
+  "editor.server": "Editor server",
+  "editor.session": "Editor session",
+  "editor.project": "Draft",
+  "editor.ai": "AI Assist",
+  "editor.mockRoot": "Mock file root"
+};
+var EDITOR_SERVER_STOPPED_SUMMARY = "The editor server stopped.";
+var EDITOR_SERVER_PASS_SUMMARY = "The editor server answered.";
+var EDITOR_SERVER_REJECTED_SUMMARY = "The editor server could not finish doctor.";
+var EDITOR_SERVER_REJECTED_FIX = "rogatio doctor";
+var EDITOR_SESSION_STALE_SUMMARY = "This tab is stale. Its editor token was rejected.";
+var EDITOR_SESSION_STALE_FIX = "Reload this tab";
+var EDITOR_SESSION_PASS_SUMMARY = "The editor token was accepted.";
+var EDITOR_PROJECT_INVALID_SUMMARY = "The draft is invalid.";
+var EDITOR_PROJECT_NOT_JSON_SUMMARY = "The draft is not JSON.";
+var EDITOR_PROJECT_VALID_SUMMARY = "The draft is valid.";
+var EDITOR_AI_NONE_SUMMARY = "Optional. No AI provider is configured.";
+var EDITOR_AI_NONE_FIX = "rogatio ai setup";
+var EDITOR_AI_AFTER_START_SUMMARY = "AI Assist was configured after this editor started.";
+var EDITOR_AI_AFTER_START_FIX = "Restart rogatio edit";
+var EDITOR_AI_PASS_SUMMARY = "AI Assist is available in this page.";
+var EDITOR_AI_REMOVED_SUMMARY = "AI Assist is no longer configured.";
+var EDITOR_MOCK_SAVED_SUMMARY = "A mock file root is saved.";
+var EDITOR_MOCK_MISSING_SUMMARY = "Mock rules have no saved mock file root.";
+var EDITOR_MOCK_MISSING_FIX = "Set mock file root";
+var MAX_DIAGNOSTICS2 = 20;
+var MAX_DIAGNOSTIC_FIELD = 200;
+function check2(id2, status, optional, summary, fix) {
+  return { id: id2, status, optional, summary, fix };
+}
+function combined(checks, host) {
+  const uiFailed = checks.some(
+    (item) => item.status === "fail" && item.optional === false
+  );
+  return {
+    version: 1,
+    surface: "editor",
+    ok: !uiFailed && (host === null || host.ok),
+    ui: { checks },
+    host
+  };
+}
+function quoteEditorArg(value, platform = process.platform) {
+  if (platform !== "win32") return quoteDoctorArg(value);
+  return `"${value.replaceAll("%", "%%").replaceAll('"', '""')}"`;
+}
+function editorEditFix(filePath, platform = process.platform) {
+  return `rogatio edit ${quoteEditorArg(filePath, platform)}`;
+}
+function editorVerifyFix(filePath, platform = process.platform) {
+  return `rogatio verify ${quoteEditorArg(filePath, platform)}`;
+}
+function editorServerStoppedReport(filePath) {
+  return combined(
+    [
+      check2(
+        "editor.server",
+        "fail",
+        false,
+        EDITOR_SERVER_STOPPED_SUMMARY,
+        editorEditFix(filePath)
+      )
+    ],
+    null
+  );
+}
+function editorSessionStaleReport() {
+  return combined(
+    [
+      check2("editor.server", "pass", false, EDITOR_SERVER_PASS_SUMMARY, null),
+      check2(
+        "editor.session",
+        "fail",
+        false,
+        EDITOR_SESSION_STALE_SUMMARY,
+        EDITOR_SESSION_STALE_FIX
+      )
+    ],
+    null
+  );
+}
+function editorServerRejectedReport() {
+  return combined(
+    [
+      check2(
+        "editor.server",
+        "fail",
+        false,
+        EDITOR_SERVER_REJECTED_SUMMARY,
+        EDITOR_SERVER_REJECTED_FIX
+      )
+    ],
+    null
+  );
+}
+function scrubField(value) {
+  let scrubbed = "";
+  for (const char of value) {
+    const code = char.codePointAt(0) ?? 0;
+    scrubbed += code <= 31 || code === 127 ? " " : char;
+    if (scrubbed.length >= MAX_DIAGNOSTIC_FIELD) break;
+  }
+  return scrubbed.slice(0, MAX_DIAGNOSTIC_FIELD);
+}
+function diagnosticLines(diagnostics) {
+  const shown = diagnostics.slice(0, MAX_DIAGNOSTICS2).map((item) => {
+    return `${scrubField(item.path)}: ${scrubField(item.message)} (${scrubField(item.code)})`;
+  });
+  const text = shown.join("\n");
+  if (diagnostics.length <= MAX_DIAGNOSTICS2) return text;
+  return `${text}
+${diagnostics.length - MAX_DIAGNOSTICS2} more`;
+}
+function projectCheck2(draft, parsed, filePath) {
+  const fix = editorVerifyFix(filePath);
+  if (!parsed) {
+    return check2(
+      "editor.project",
+      "fail",
+      false,
+      EDITOR_PROJECT_NOT_JSON_SUMMARY,
+      fix
+    );
+  }
+  try {
+    const diagnosis = diagnoseProjectData(draft);
+    if (diagnosis.diagnostics.length === 0) {
+      return check2(
+        "editor.project",
+        "pass",
+        false,
+        EDITOR_PROJECT_VALID_SUMMARY,
+        null
+      );
+    }
+    const lines = diagnosticLines(diagnosis.diagnostics);
+    return check2(
+      "editor.project",
+      "fail",
+      false,
+      lines.length > 0 ? `${EDITOR_PROJECT_INVALID_SUMMARY}
+${lines}` : EDITOR_PROJECT_INVALID_SUMMARY,
+      fix
+    );
+  } catch {
+    return check2(
+      "editor.project",
+      "fail",
+      false,
+      EDITOR_PROJECT_INVALID_SUMMARY,
+      fix
+    );
+  }
+}
+function aiCheck2(assistInPage, configuredNow) {
+  if (!assistInPage && !configuredNow) {
+    return check2(
+      "editor.ai",
+      "warn",
+      true,
+      EDITOR_AI_NONE_SUMMARY,
+      EDITOR_AI_NONE_FIX
+    );
+  }
+  if (!assistInPage && configuredNow) {
+    return check2(
+      "editor.ai",
+      "warn",
+      true,
+      EDITOR_AI_AFTER_START_SUMMARY,
+      EDITOR_AI_AFTER_START_FIX
+    );
+  }
+  if (assistInPage && configuredNow) {
+    return check2("editor.ai", "pass", true, EDITOR_AI_PASS_SUMMARY, null);
+  }
+  return check2(
+    "editor.ai",
+    "warn",
+    true,
+    EDITOR_AI_REMOVED_SUMMARY,
+    EDITOR_AI_NONE_FIX
+  );
+}
+function draftHasMockRule(draft) {
+  if (draft === null || typeof draft !== "object" || Array.isArray(draft)) {
+    return false;
+  }
+  const groups = draft.groups;
+  if (!Array.isArray(groups)) return false;
+  for (const group of groups) {
+    if (group === null || typeof group !== "object" || Array.isArray(group)) {
+      continue;
+    }
+    const rules = group.rules;
+    if (!Array.isArray(rules)) continue;
+    for (const rule of rules) {
+      if (rule === null || typeof rule !== "object" || Array.isArray(rule)) {
+        continue;
+      }
+      if (rule.type === "mock") return true;
+    }
+  }
+  return false;
+}
+function mockRootCheck(saved) {
+  if (saved) {
+    return check2(
+      "editor.mockRoot",
+      "pass",
+      true,
+      EDITOR_MOCK_SAVED_SUMMARY,
+      null
+    );
+  }
+  return check2(
+    "editor.mockRoot",
+    "warn",
+    true,
+    EDITOR_MOCK_MISSING_SUMMARY,
+    EDITOR_MOCK_MISSING_FIX
+  );
+}
+function buildEditorDoctor(input) {
+  const checks = [
+    check2("editor.server", "pass", false, EDITOR_SERVER_PASS_SUMMARY, null),
+    check2("editor.session", "pass", false, EDITOR_SESSION_PASS_SUMMARY, null),
+    projectCheck2(input.draft, input.draftParsed, input.filePath),
+    aiCheck2(input.assistInPage, input.configuredNow)
+  ];
+  if (input.draftParsed && draftHasMockRule(input.draft)) {
+    checks.push(mockRootCheck(input.mockRootSaved));
+  }
+  return combined(checks, input.host);
+}
+function mapReadError2(error) {
+  if (error instanceof ProjectStorageError) {
+    if (error.code === "not-found") return { ok: false, reason: "missing" };
+    if (error.code === "invalid-json" || error.code === "invalid-format") {
+      return { ok: false, reason: "parse" };
+    }
+  }
+  return { ok: false, reason: "unreadable" };
+}
+function editorFileDoctorOptions(input) {
+  return {
+    cliVersion: input.cliVersion,
+    checkUpdates: false,
+    project: {
+      source: "file",
+      path: input.filePath,
+      read: input.read
+    }
+  };
+}
+async function runEditorFileDoctor(input) {
+  try {
+    return await runInstalledDoctor(
+      editorFileDoctorOptions({
+        filePath: input.filePath,
+        cliVersion: input.cliVersion,
+        read: async () => {
+          try {
+            return { ok: true, data: await input.storageGet(input.filePath) };
+          } catch (error) {
+            return mapReadError2(error);
+          }
+        }
+      })
+    );
+  } catch {
+    return doctorInterruptedReport();
+  }
+}
+function serializeEditorDiagnostics(report2) {
+  return `${JSON.stringify(
+    {
+      version: 1,
+      surface: "editor",
+      ok: report2.ok,
+      ui: {
+        checks: report2.ui.checks.map((item) => ({
+          id: item.id,
+          status: item.status,
+          optional: item.optional,
+          summary: item.summary,
+          fix: item.fix
+        }))
+      },
+      host: report2.host === null ? null : doctorReportValue(report2.host)
+    },
+    null,
+    2
+  )}
+`;
+}
+function embedJson(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003c");
+}
+function editorPageTitles() {
+  return {
+    ...EDITOR_CHECK_TITLES,
+    node: "Node and CLI",
+    project: "Project file",
+    host: "Native host",
+    ca: "Device CA",
+    pac: "Runtime PAC",
+    ai: "AI Assist"
+  };
+}
+
 // packages/cli/src/server/http.ts
 import {
   createServer as createHttpServer
@@ -29093,6 +29419,67 @@ function createRoutes(context) {
       res.end(JSON.stringify({ diagnostics: diagnosis.diagnostics }));
       return;
     }
+    if (pathname === "/api/doctor" && method === "POST") {
+      if (!validateCsrf(req, context.csrfToken)) {
+        res.writeHead(403, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            code: "csrf-invalid",
+            message: "Invalid CSRF token"
+          })
+        );
+        return;
+      }
+      let draft = context.project;
+      let draftParsed = true;
+      try {
+        const bodyText = await getRequestBody(req);
+        if (bodyText.length > 0) draft = JSON.parse(bodyText);
+      } catch (error) {
+        if (error instanceof RequestBodyError) {
+          const failure2 = bodyErrorResponse(error);
+          res.writeHead(failure2.status, { "Content-Type": "application/json" });
+          res.end(JSON.stringify(failure2.body));
+          return;
+        }
+        draftParsed = false;
+      }
+      let host2;
+      try {
+        host2 = context.runFileDoctor ? await context.runFileDoctor() : await runEditorFileDoctor({
+          filePath: context.filePath,
+          cliVersion: readCliVersion(),
+          storageGet: (path2) => context.storage.get(path2)
+        });
+      } catch {
+        host2 = doctorInterruptedReport();
+      }
+      let configuredNow = false;
+      try {
+        const config = await (context.readProviderConfig ?? (async () => null))();
+        configuredNow = config !== null && config !== void 0;
+      } catch {
+        configuredNow = false;
+      }
+      let mockRootSaved = false;
+      try {
+        mockRootSaved = await readSavedMockRoot(context.filePath) !== void 0;
+      } catch {
+        mockRootSaved = false;
+      }
+      const report2 = buildEditorDoctor({
+        filePath: context.filePath,
+        draft,
+        draftParsed,
+        assistInPage: context.aiClient !== void 0,
+        configuredNow,
+        mockRootSaved,
+        host: host2
+      });
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(serializeEditorDiagnostics(report2));
+      return;
+    }
     if (pathname === "/api/mock-root" && method === "GET") {
       const saved = await readSavedMockRoot(context.filePath);
       res.writeHead(200, { "Content-Type": "application/json" });
@@ -29669,7 +30056,8 @@ async function editCommand(args, options = {}) {
     editorCssPath: "",
     editorFontsPath: "",
     aiClient,
-    aiProviderConfig: providerConfig ?? void 0
+    aiProviderConfig: providerConfig ?? void 0,
+    readProviderConfig
   };
   let server;
   try {
@@ -29799,9 +30187,23 @@ function generateEditorHtml(apiBase, csrfToken, filePath, aiConfigured) {
       background-size: 24px 24px;
     }
     #editor-root { min-height: 100vh; }
+    #editor-doctor {
+      position: sticky;
+      top: 0;
+      z-index: 2;
+      background: #1c1f24;
+      color: #e7eaf0;
+      padding: 12px 16px;
+      font: 13px/1.45 ui-monospace, monospace;
+      white-space: pre-wrap;
+    }
+    #editor-doctor[hidden] { display: none; }
+    #editor-doctor p { margin: 0 0 0.35rem; }
+    #editor-doctor button { margin-top: 0.5rem; }
   </style>
 </head>
 <body>
+   <div id="editor-doctor" hidden></div>
    <div id="editor-root"></div>
    <script type="importmap">
      { "imports": { "@rogatio/editor": "/vendor/editor.js" } }
@@ -29812,7 +30214,11 @@ function generateEditorHtml(apiBase, csrfToken, filePath, aiConfigured) {
     const root = document.getElementById('editor-root');
     const apiBase = ${JSON.stringify(apiBase)};
     const csrfToken = ${JSON.stringify(csrfToken)};
-    const filePath = ${JSON.stringify(filePath)};
+    const filePath = ${embedJson(filePath)};
+    const doctorTitles = ${embedJson(editorPageTitles())};
+    const serverStoppedJson = ${embedJson(serializeEditorDiagnostics(editorServerStoppedReport(filePath)))};
+    const sessionStaleJson = ${embedJson(serializeEditorDiagnostics(editorSessionStaleReport()))};
+    const serverRejectedJson = ${embedJson(serializeEditorDiagnostics(editorServerRejectedReport()))};
     
     async function fetchProject() {
       const res = await fetch(apiBase + '/api/project');
@@ -29961,15 +30367,110 @@ function generateEditorHtml(apiBase, csrfToken, filePath, aiConfigured) {
           cancel();
         },
         projectActions: [
+          { command: 'run-doctor', label: 'Run checks' },
           { command: 'set-mock-root', label: 'Set mock file root' },
           { command: 'clear-mock-root', label: 'Clear mock file root' },
         ],
         ${aiAssistHandler}
       });
+      let lastDoctorJson = '';
+      let doctorRunning = false;
+      function renderDoctor(report, rawJson) {
+        const panel = document.getElementById('editor-doctor');
+        if (!panel) return;
+        panel.replaceChildren();
+        panel.hidden = false;
+        lastDoctorJson = rawJson;
+        const ui = report && report.ui && Array.isArray(report.ui.checks)
+          ? report.ui.checks
+          : [];
+        const host = report && report.host && Array.isArray(report.host.checks)
+          ? report.host.checks
+          : [];
+        for (const item of ui.concat(host)) {
+          if (!item || typeof item.summary !== 'string' || typeof item.status !== 'string') {
+            continue;
+          }
+          const id = typeof item.id === 'string' ? item.id : '';
+          const title = Object.prototype.hasOwnProperty.call(doctorTitles, id)
+            ? doctorTitles[id]
+            : id;
+          const line = document.createElement('p');
+          line.dataset.check = id;
+          const fix = typeof item.fix === 'string' ? item.fix : null;
+          line.textContent = fix === null
+            ? item.status + '  ' + title + '  ' + item.summary
+            : item.status + '  ' + title + '  ' + item.summary + '\\nFix: ' + fix;
+          panel.append(line);
+        }
+        const copy = document.createElement('button');
+        copy.type = 'button';
+        copy.textContent = 'Copy diagnostics';
+        copy.addEventListener('click', () => {
+          if (navigator.clipboard && navigator.clipboard.writeText) {
+            void navigator.clipboard.writeText(lastDoctorJson);
+          }
+        });
+        panel.append(copy);
+      }
+      async function runEditorDoctor() {
+        if (doctorRunning) return;
+        doctorRunning = true;
+        try {
+          let body;
+          try {
+            body = JSON.stringify(editor.getDraft());
+          } catch (error) {
+            renderDoctor(JSON.parse(serverRejectedJson), serverRejectedJson);
+            return;
+          }
+          let res;
+          try {
+            res = await fetch(apiBase + '/api/doctor', {
+              method: 'POST',
+              headers: {
+                'Content-Type': 'application/json',
+                'X-CSRF-Token': csrfToken,
+              },
+              body,
+            });
+          } catch (error) {
+            renderDoctor(JSON.parse(serverStoppedJson), serverStoppedJson);
+            return;
+          }
+          const text = await res.text();
+          if (res.status === 403) {
+            let payload = null;
+            try { payload = JSON.parse(text); } catch (error) { payload = null; }
+            if (payload && payload.code === 'csrf-invalid') {
+              renderDoctor(JSON.parse(sessionStaleJson), sessionStaleJson);
+              return;
+            }
+          }
+          if (!res.ok) {
+            renderDoctor(JSON.parse(serverRejectedJson), serverRejectedJson);
+            return;
+          }
+          let report;
+          try {
+            report = JSON.parse(text);
+          } catch (error) {
+            renderDoctor(JSON.parse(serverRejectedJson), serverRejectedJson);
+            return;
+          }
+          renderDoctor(report, text);
+        } finally {
+          doctorRunning = false;
+        }
+      }
       document.addEventListener('click', (event) => {
         const target = event.target;
         if (!(target instanceof Element)) return;
         const command = target.closest('[data-command]')?.getAttribute('data-command');
+        if (command === 'run-doctor') {
+          void runEditorDoctor();
+          return;
+        }
         if (command !== 'set-mock-root' && command !== 'clear-mock-root') return;
         const root = command === 'clear-mock-root'
           ? null

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rogatio/cli",
-  "version": "6.15.0",
+  "version": "6.16.0",
   "private": false,
   "type": "module",
   "description": "Local-first browser request and response rules — editor host, file verification, test runner, and runtime dispatch.",