@jxsuite/studio 0.37.0 → 1.0.0

package/src/page-params.ts

@@ -11,6 +11,7 @@
  */
 
 import { getPlatform } from "./platform";
+import { loadExtensions } from "./format/format-host";
 import type { JxMutableNode, JxPathsDef } from "@jxsuite/schema/types";
 
 /** Param name → candidate values, in `$paths` declaration order. */
@@ -135,10 +136,15 @@ async function resolveParamValues(pathsDef: JxPathsDef): Promise<ParamValues> {
     return out;
   }
 
-  // Content type-based: { contentType: "blog", param: "slug", field: "id" } — resolved through the
-  // Backend's ContentCollection pipeline (the same one the canvas's ContentEntry uses), so every
-  // Offered value is guaranteed to resolve in preview.
-  if ("contentType" in pathsDef && pathsDef.contentType) {
+  // Content type-based: { contentType: "blog", param: "slug", field: "id" } — an open extension
+  // Discriminator member on JxPathsDef, so narrow to string. Resolved through the backend's
+  // ContentCollection pipeline (the same one the canvas's ContentEntry uses), so every offered
+  // Value is guaranteed to resolve in preview.
+  if (
+    "contentType" in pathsDef &&
+    typeof pathsDef.contentType === "string" &&
+    pathsDef.contentType
+  ) {
     const param = pathsDef.param ?? "slug";
     const field = pathsDef.field ?? "id";
     const entries = (await resolveContentCollection(pathsDef.contentType)) as {
@@ -165,8 +171,9 @@ async function resolveParamValues(pathsDef: JxPathsDef): Promise<ParamValues> {
     return out;
   }
 
-  // Data file ref: { "$ref": "./data/products.json", param: "id", field: "sku" }
-  if ("$ref" in pathsDef && pathsDef.$ref) {
+  // Data file ref: { "$ref": "./data/products.json", param: "id", field: "sku" } — `$ref` also
+  // Reaches here as an open discriminator key, so narrow to a non-empty string.
+  if ("$ref" in pathsDef && typeof pathsDef.$ref === "string" && pathsDef.$ref) {
     const param = pathsDef.param ?? "id";
     const field = pathsDef.field ?? "id";
     const content = await getPlatform().readFile(pathsDef.$ref.replace(/^\.\//, ""));
@@ -184,6 +191,25 @@ async function resolveParamValues(pathsDef: JxPathsDef): Promise<ParamValues> {
   return {};
 }
 
+/**
+ * The `$src` of the ContentCollection class from the enabled extensions payload — whichever
+ * extension's manifest declares a class named `ContentCollection` (its backend-resolved descriptor
+ * path feeds `/__jx_resolve__` directly). Platforms without an extensions payload fall back to the
+ * historical parser-package specifier.
+ *
+ * @returns {Promise<string>}
+ */
+async function contentCollectionSrc(): Promise<string> {
+  const extensions = await loadExtensions();
+  for (const ext of extensions) {
+    const cls = ext.classes?.find((c) => c.name === "ContentCollection");
+    if (cls) {
+      return cls.path;
+    }
+  }
+  return "@jxsuite/parser/ContentCollection.class.json";
+}
+
 /**
  * Resolve a ContentCollection for a content type via the PAL, falling back to a plain dev-proxy
  * fetch on platforms that predate `resolveClass`.
@@ -191,10 +217,10 @@ async function resolveParamValues(pathsDef: JxPathsDef): Promise<ParamValues> {
  * @param {string} contentType
  * @returns {Promise<unknown>}
  */
-function resolveContentCollection(contentType: string) {
+async function resolveContentCollection(contentType: string) {
   const body = {
     $prototype: "ContentCollection",
-    $src: "@jxsuite/parser/ContentCollection.class.json",
+    $src: await contentCollectionSrc(),
     contentType,
   };
   const platform = getPlatform();

package/src/panels/ai-chat/chat-markdown.ts

@@ -1,7 +1,7 @@
 /**
  * Chat-markdown.js — memoized markdown rendering for assistant chat messages.
  *
- * Wraps @jxsuite/parser/md-html (sanitized markdown → HTML) with a per-message cache
+ * Wraps @jxsuite/markup/md-html (sanitized markdown → HTML) with a per-message cache
  * keyed by message id + content length, so re-renders during streaming only re-parse
  * the message that actually grew. The HTML goes through unsafeHTML, which is safe here
  * because md-html sanitizes (raw HTML dropped, javascript: URLs stripped).
@@ -12,7 +12,7 @@
 import { html } from "lit-html";
 import type { TemplateResult } from "lit-html";
 import { unsafeHTML } from "lit-html/directives/unsafe-html.js";
-import { markdownToHtml } from "@jxsuite/parser/md-html";
+import { markdownToHtml } from "@jxsuite/markup/md-html";
 
 const cache = new Map<string, { len: number; html: string }>();
 

package/src/panels/ai-panel.ts

@@ -16,12 +16,13 @@
  * @license MIT
  */
 
-import { html, render as litRender } from "lit-html";
+import { html, render as litRender, nothing } from "lit-html";
 import type { TemplateResult } from "lit-html";
+import { getPlatform } from "../platform";
 import { effect, effectScope } from "../reactivity";
 import { createDocumentAssistant } from "../services/document-assistant";
 import { hasOpenAiKey } from "../services/ai-settings";
-import { fetchAvailableModels, isProxyConfigured } from "../services/ai-models";
+import { fetchAvailableModels, isManagedProxy, isProxyConfigured } from "../services/ai-models";
 import { createAiCredentialsForm } from "../ui/ai-credentials-form";
 import { clearMarkdownCache } from "./ai-chat/chat-markdown";
 import { renderChatHeader, renderMessageList } from "./ai-chat/chat-view";
@@ -168,11 +169,67 @@ function startEditApiKey() {
   credsForm.startEdit();
 }
 
-/** The OpenAI (or compatible) key + endpoint settings form, shown as a gate when no key is set. */
+// ─── Managed Cloudflare connect (Workers AI) ─────────────────────────────────
+
+let cfConnectBusy = false;
+let cfConnectError = "";
+
+/**
+ * Managed platforms broker Workers AI on the user's own Cloudflare account: offer connecting it as
+ * the keyless alternative whenever the proxy says managed-but-unconfigured and the platform can run
+ * the hosted OAuth flow (the PAL seam — desktop shells can implement cfConnect later).
+ */
+function canOfferManagedConnect(): boolean {
+  return isManagedProxy() && !isProxyConfigured() && Boolean(getPlatform().cfConnect);
+}
+
+async function connectCloudflareForAi() {
+  if (cfConnectBusy) {
+    return;
+  }
+  cfConnectBusy = true;
+  cfConnectError = "";
+  scheduleAiRender();
+  try {
+    const connection = await getPlatform().cfConnect?.();
+    if (connection) {
+      // Re-probe: /models flips to configured once the connection lands, opening the gate.
+      await fetchAvailableModels({ force: true });
+    } else {
+      cfConnectError = "Cloudflare connection was not completed.";
+    }
+  } catch (error) {
+    cfConnectError = error instanceof Error ? error.message : String(error);
+  }
+  cfConnectBusy = false;
+  scheduleAiRender();
+}
+
+function renderManagedConnect() {
+  return html`
+    <div class="ai-managed-connect">
+      <div>Use Workers AI on your own Cloudflare account — no API key needed.</div>
+      <sp-button size="s" ?disabled=${cfConnectBusy} @click=${() => void connectCloudflareForAi()}>
+        ${cfConnectBusy ? "Connecting…" : "Connect Cloudflare"}
+      </sp-button>
+      ${cfConnectError
+        ? html`<div class="ai-managed-connect-error">${cfConnectError}</div>`
+        : nothing}
+      <div class="ai-managed-connect-divider">— or bring your own key —</div>
+    </div>
+  `;
+}
+
+/**
+ * The credentials gate: on managed platforms a keyless "Connect Cloudflare" (Workers AI) option
+ * sits above the OpenAI-compatible key form — both are real, working paths.
+ */
 function renderKeyGate() {
   return html`
     <div class="ai-tab-body">
-      <div class="ai-status-center">${credsForm.render()}</div>
+      <div class="ai-status-center">
+        ${canOfferManagedConnect() ? renderManagedConnect() : nothing} ${credsForm.render()}
+      </div>
     </div>
   `;
 }