@opengeni/react 3.3.2 → 3.4.1-canary.38960406141001

package/src/device-authorization.tsx

@@ -0,0 +1,98 @@
+import { useEffect, useRef, useState, type ReactNode } from "react";
+import { copyTextToClipboard } from "./clipboard";
+
+export type DeviceAuthorizationProps = {
+  userCode: string;
+  verificationUri: string;
+  providerLabel?: string;
+  description?: string;
+  className?: string;
+  codeAttributes?: Record<`data-${string}`, string>;
+  loadClipboard?: () => Promise<{ copyTextToClipboard(text: string): Promise<boolean> }>;
+  onCopyResult?: (copied: boolean) => void;
+  /** Optional host presentation; clipboard state and URL validation remain shared. */
+  render?: (state: {
+    copied: boolean;
+    copyError: boolean;
+    copy: () => Promise<void>;
+    verificationHref: string | undefined;
+  }) => ReactNode;
+};
+
+/** Optional presentation for the existing model-account device APIs. It neither
+ * owns provider state nor assumes that opening a verification page completed it. */
+export function DeviceAuthorization(props: DeviceAuthorizationProps) {
+  const [copied, setCopied] = useState(false);
+  const [copyError, setCopyError] = useState(false);
+  const generation = useRef(0);
+  const timer = useRef<ReturnType<typeof setTimeout> | null>(null);
+  useEffect(() => {
+    generation.current++;
+    setCopied(false);
+    setCopyError(false);
+    return () => {
+      // This is a live async-operation counter, not a captured DOM ref.
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      generation.current++;
+      if (timer.current) clearTimeout(timer.current);
+    };
+  }, [props.userCode]);
+  async function copy() {
+    const revision = ++generation.current;
+    if (timer.current) clearTimeout(timer.current);
+    setCopied(false);
+    setCopyError(false);
+    try {
+      const clipboard = props.loadClipboard ? await props.loadClipboard() : { copyTextToClipboard };
+      if (revision !== generation.current) return;
+      const success = await clipboard.copyTextToClipboard(props.userCode);
+      if (revision !== generation.current) return;
+      setCopied(success);
+      setCopyError(!success);
+      props.onCopyResult?.(success);
+      if (success)
+        timer.current = setTimeout(() => {
+          if (revision === generation.current) setCopied(false);
+        }, 1600);
+    } catch {
+      if (revision !== generation.current) return;
+      setCopyError(true);
+      props.onCopyResult?.(false);
+    }
+  }
+  let href: string | undefined;
+  try {
+    const url = new URL(props.verificationUri);
+    if (["https:", "http:"].includes(url.protocol) && !url.username && !url.password)
+      href = props.verificationUri;
+  } catch {
+    /* A malformed provider URL must never become an executable link. */
+  }
+  if (props.render) return props.render({ copied, copyError, copy, verificationHref: href });
+  return (
+    <section className={`og-connect ${props.className ?? ""}`} aria-label="Device authorization">
+      <p>{props.description ?? `Enter this code at ${props.providerLabel ?? "the provider"}.`}</p>
+      <div style={{ display: "flex", flexWrap: "wrap", gap: "0.5rem", alignItems: "center" }}>
+        <code {...props.codeAttributes} style={{ overflowWrap: "anywhere" }}>
+          {props.userCode}
+        </code>
+        <button
+          type="button"
+          aria-label={copied ? "Code copied" : "Copy code"}
+          onClick={() => void copy()}
+        >
+          {copied ? "Copied" : "Copy code"}
+        </button>
+        {href ? (
+          <a href={href} target="_blank" rel="noopener noreferrer">
+            Open {props.providerLabel ?? "auth page"}
+          </a>
+        ) : (
+          <span role="alert">Authorization address unavailable.</span>
+        )}
+      </div>
+      {copyError ? <p role="alert">Couldn't copy the code. Copy it manually instead.</p> : null}
+      <p role="status">Waiting for authorization…</p>
+    </section>
+  );
+}

package/src/diffs.ts

@@ -0,0 +1,16 @@
+import { registerPierreDiffs } from "./lib/pierre-diffs-loader";
+
+export { registerPierreDiffs, type PierreDiffsLoader } from "./lib/pierre-diffs-loader";
+
+/**
+ * Enable Shiki-highlighted diffs and file views from the optional
+ * `@pierre/diffs` peer. Call once at startup, only when the host installs it.
+ * This is the only module in the package that names the peer, so hosts that
+ * skip it build without `@pierre/diffs` and render plain-text diffs.
+ */
+export function enablePierreDiffs(): void {
+  registerPierreDiffs(loadPierreDiffsModule);
+}
+
+// One stable loader identity, so repeated enable calls are no-ops.
+const loadPierreDiffsModule = () => import("@pierre/diffs/react");

package/src/discovery-cache.ts

@@ -0,0 +1,42 @@
+/** Short-lived presentation data only. Never cache installation or authorization state. */
+export function createDiscoveryCache<T>(ttlMs = 60_000, capacity = 64) {
+  const clients = new WeakMap<
+    object,
+    Map<string, { expires: number; value: T | undefined; pending: Promise<T> }>
+  >();
+  return {
+    peek(client: object, key: string): T | undefined {
+      const entry = clients.get(client)?.get(key);
+      return entry && entry.expires > Date.now() ? entry.value : undefined;
+    },
+    read(client: object, key: string, fetch: () => Promise<T>): Promise<T> {
+      let entries = clients.get(client);
+      if (!entries) {
+        entries = new Map();
+        clients.set(client, entries);
+      }
+      const existing = entries.get(key);
+      if (existing && existing.expires > Date.now()) return existing.pending;
+      entries.delete(key);
+      while (entries.size >= capacity) entries.delete(entries.keys().next().value!);
+      const entry = {
+        expires: Date.now() + ttlMs,
+        value: undefined as T | undefined,
+        pending: Promise.resolve().then(fetch),
+      };
+      entries.set(key, entry);
+      entry.pending = entry.pending.then(
+        (value) => {
+          entry.value = value;
+          entry.expires = Date.now() + ttlMs;
+          return value;
+        },
+        (error) => {
+          if (entries.get(key) === entry) entries.delete(key);
+          throw error;
+        },
+      );
+      return entry.pending;
+    },
+  };
+}

package/src/editor.ts

@@ -0,0 +1,13 @@
+import { registerCodeEditor, type CodeEditorLanguages } from "./lib/workbench-peers";
+
+export { CodeEditor, languageForPath } from "./components/code-editor";
+export type { CodeEditorProps } from "./components/code-editor";
+export { registerCodeEditor } from "./lib/workbench-peers";
+export type { CodeEditorLanguage, CodeEditorLanguages } from "./lib/workbench-peers";
+
+const loadEditor = async () => ({ module: await import("@uiw/react-codemirror") });
+
+/** Only name installed grammar peers in host-supplied language loaders. */
+export function enableCodeEditor(languages?: CodeEditorLanguages): void {
+  registerCodeEditor(languages ? async () => ({ ...(await loadEditor()), languages }) : loadEditor);
+}

package/src/hooks/internal.ts

@@ -1,6 +1,7 @@
 import type { SessionEvent } from "@opengeni/sdk";
 import { useCallback, useEffect, useLayoutEffect, useRef, useState } from "react";
 import type { EmbeddedSessionEventClientLike } from "../client";
+import { normalizeError } from "../lib/error-message";
 
 const HIDDEN_STREAM_GRACE_MS = 2_000;
 
@@ -116,7 +117,7 @@ export function usePolledValue<T>(
           activeLoadRef.current === load &&
           !requestAbort.signal.aborted
         ) {
-          setError(cause instanceof Error ? cause : new Error(String(cause)));
+          setError(normalizeError(cause));
           setLoading(false);
         }
       } finally {
@@ -258,7 +259,7 @@ export function useMutationRunner(identity: unknown = undefined): MutationState
           generation.current === ownedGeneration &&
           Object.is(identityRef.current, ownedIdentity)
         ) {
-          setMutationError(cause instanceof Error ? cause : new Error(String(cause)));
+          setMutationError(normalizeError(cause));
         }
         return null;
       } finally {

package/src/hooks/latest-question.ts

@@ -0,0 +1,164 @@
+import { SESSION_EVENT_TYPES, type SessionEvent, type SessionTurn } from "@opengeni/sdk";
+import type { EmbeddedSessionClientLike } from "../client";
+import {
+  isTimelineUserQuestion,
+  isTurnExecutionEvidence,
+  timelineQuestionPlacement,
+} from "../timeline/projection";
+
+export type LatestQuestionOptions = {
+  /** Check navigation.isCurrent() after awaits and immediately before UI effects. */
+  onQueuedQuestion?: (
+    turn: SessionTurn,
+    navigation: { isCurrent: () => boolean },
+  ) => void | Promise<void>;
+};
+
+/** Include every canonical execution fallback, not just turn.started. Derive
+ * this optional navigation index only when the user requests Latest question. */
+export const TIMELINE_TURN_ANCHOR_EVENT_TYPES = SESSION_EVENT_TYPES.filter(
+  (type) =>
+    isTurnExecutionEvidence(type) ||
+    type === "turn.queued" ||
+    type === "turn.started" ||
+    type === "turn.cancelled" ||
+    type === "session.queue.changed" ||
+    type === "session.control.steer_requested",
+);
+
+/** Resolve an optional navigation destination without owning the hook's window
+ * or React state. The caller guards errors and applies only a current result. */
+export async function resolveLatestQuestion({
+  client,
+  workspaceId,
+  sessionId,
+  isCurrent,
+  resumeSequence,
+  options,
+}: {
+  client: EmbeddedSessionClientLike;
+  workspaceId: string;
+  sessionId: string;
+  isCurrent: () => boolean;
+  resumeSequence: (events: readonly SessionEvent[]) => number;
+  options?: LatestQuestionOptions | undefined;
+}): Promise<{ questionSequence: number; anchor: number; events: SessionEvent[] } | null> {
+  let before: number | undefined;
+  while (true) {
+    const latest = await client.listEvents(workspaceId, sessionId, {
+      direction: "before",
+      includeTypes: ["user.message"],
+      // Historical worker completions also used user.message; page only this
+      // filtered index when they occupy the tail.
+      limit: before === undefined ? 1 : 64,
+      ...(before === undefined ? {} : { before }),
+      payloadMode: "full",
+      mode: "forensic",
+    });
+    if (!isCurrent()) return null;
+    // Keep legacy childCompletion classification aligned with the transcript.
+    const question = [...latest]
+      .sort((a, b) => b.sequence - a.sequence)
+      .find(isTimelineUserQuestion);
+    if (question) {
+      const queue = await client.getQueue(workspaceId, sessionId);
+      if (!isCurrent()) return null;
+      const pending = queue.items.find(
+        (turn) => turn.triggerEventId === question.id && turn.metadata.delivery !== "steer",
+      );
+      if (pending) {
+        if (!options?.onQueuedQuestion) {
+          const reason = new Error("The latest question is in the prompt queue.");
+          reason.name = "LatestQuestionQueuedError";
+          throw reason;
+        }
+        await options.onQueuedQuestion(pending, { isCurrent });
+        if (!isCurrent()) return null;
+        // Queue refresh/focus can race a claim or withdrawal. Resolve that
+        // transition below instead of settling on a row that just vanished.
+        const refreshedQueue = await client.getQueue(workspaceId, sessionId);
+        if (!isCurrent()) return null;
+        if (
+          refreshedQueue.items.some(
+            (turn) => turn.triggerEventId === question.id && turn.metadata.delivery !== "steer",
+          )
+        )
+          return null;
+      }
+      const evidence: SessionEvent[] = [];
+      const payload =
+        question.payload != null && typeof question.payload === "object"
+          ? (question.payload as Record<string, unknown>)
+          : {};
+      // Explicit direct admission needs no lifecycle lookup. Older ledgers and
+      // queued admission need their durable start/withdrawal witnesses.
+      if (
+        payload.routing !== "accepted_for_execution" &&
+        payload.routing !== "accepted_for_steering" &&
+        payload.delivery !== "steer"
+      ) {
+        let lifecycleAfter = question.sequence;
+        while (true) {
+          const page = await client.listEvents(workspaceId, sessionId, {
+            direction: "after",
+            after: lifecycleAfter,
+            limit: 128,
+            compact: true,
+            mode: "forensic",
+            payloadMode: "full",
+            includeTypes: TIMELINE_TURN_ANCHOR_EVENT_TYPES,
+          });
+          if (!isCurrent()) return null;
+          const next = Math.max(lifecycleAfter, resumeSequence(page));
+          if (next === lifecycleAfter) break;
+          const queued =
+            page.find(
+              (event) =>
+                event.type === "turn.queued" &&
+                ((event.payload ?? {}) as Record<string, unknown>).triggerEventId === question.id,
+            ) ?? evidence.find((event) => event.type === "turn.queued");
+          const turnId =
+            queued && (((queued.payload ?? {}) as Record<string, unknown>).turnId ?? queued.turnId);
+          evidence.push(
+            ...page.filter((event) => {
+              const data = (event.payload ?? {}) as Record<string, unknown>;
+              return (
+                data.triggerEventId === question.id ||
+                (turnId != null &&
+                  (event.turnId === turnId ||
+                    data.turnId === turnId ||
+                    data.targetTurnId === turnId))
+              );
+            }),
+          );
+          lifecycleAfter = next;
+          const placed = timelineQuestionPlacement(question, evidence);
+          if (placed.kind === "visible" && placed.sequence !== question.sequence) break;
+        }
+      }
+      const placement = timelineQuestionPlacement(question, evidence);
+      if (placement.kind === "withdrawn") {
+        before = question.sequence;
+        continue;
+      }
+      if (placement.kind === "pending")
+        throw new Error("The latest question is changing queue state. Try again.");
+      return {
+        questionSequence: question.sequence,
+        anchor: placement.sequence,
+        events: [
+          question,
+          ...evidence.filter(
+            (event) =>
+              event.type === "turn.queued" &&
+              ((event.payload ?? {}) as Record<string, unknown>).triggerEventId === question.id,
+          ),
+        ],
+      };
+    }
+    const oldest = Math.min(...latest.map((event) => event.sequence));
+    if (!Number.isSafeInteger(oldest) || oldest <= 1 || (before !== undefined && oldest >= before))
+      return null;
+    before = oldest;
+  }
+}

package/src/hooks/shared-machines-list.ts

@@ -31,10 +31,22 @@ type Share = {
   inFlight: Promise<void> | null;
   trailing: Promise<void> | null;
   generation: number;
+  /** The last read was refused (401/403/404). Polling stays stopped until the
+   *  read is disabled (a permission/workspace change) or explicitly refreshed. */
+  halted: boolean;
 };
 
 const shares = new Map<string, Share>();
 
+/** A refusal that repeating the identical read cannot fix: the caller lacks
+ *  `enrollments:read` (403), is signed out (401), or the workspace/feature is
+ *  gone (404). Structural so host adapters with their own error types work. */
+export function isMachinesAccessRefusal(cause: unknown): boolean {
+  if (!cause || typeof cause !== "object" || !("status" in cause)) return false;
+  const status = (cause as { status: unknown }).status;
+  return status === 401 || status === 403 || status === 404;
+}
+
 function emit(share: Share): void {
   for (const subscriber of share.subscribers) {
     subscriber.onChange();
@@ -81,6 +93,7 @@ function cancelDispose(share: Share): void {
 
 function arm(share: Share): void {
   stopTimer(share);
+  if (share.halted) return;
   const { enabled, pollIntervalMs } = effective(share);
   if (!enabled || pollIntervalMs === undefined) return;
   share.timer = setTimeout(() => {
@@ -98,10 +111,15 @@ async function runFresh(share: Share): Promise<void> {
   try {
     const data = await load(abort.signal);
     if (ticket !== share.generation || abort.signal.aborted) return;
+    share.halted = false;
     share.snapshot = { data, loading: false, error: null };
     emit(share);
   } catch (cause) {
     if (ticket !== share.generation || abort.signal.aborted) return;
+    if (isMachinesAccessRefusal(cause)) {
+      share.halted = true;
+      stopTimer(share);
+    }
     share.snapshot = {
       data: share.snapshot.data,
       loading: false,
@@ -120,7 +138,7 @@ function run(share: Share, force = false): Promise<void> {
     let trailing!: Promise<void>;
     trailing = share.inFlight
       .then(async () => {
-        if (!effective(share).enabled) return;
+        if (!effective(share).enabled || share.halted) return;
         await run(share);
       })
       .finally(() => {
@@ -145,12 +163,21 @@ function reconcile(share: Share): void {
     share.abort = null;
     share.inFlight = null;
     stopTimer(share);
+    if (share.halted) {
+      // Disabling is the host's permission/workspace signal. Forget the
+      // refusal so a later re-enable reads once immediately.
+      share.halted = false;
+      share.snapshot = { data: share.snapshot.data, loading: false, error: null };
+      emit(share);
+      return;
+    }
     if (share.snapshot.loading) {
       share.snapshot = { ...share.snapshot, loading: false };
       emit(share);
     }
     return;
   }
+  if (share.halted) return;
   if (share.snapshot.data !== null || share.snapshot.error) {
     arm(share);
     return;
@@ -175,6 +202,7 @@ function getOrCreate(shareKey: string): Share {
     inFlight: null,
     trailing: null,
     generation: 0,
+    halted: false,
   };
   shares.set(shareKey, created);
   return created;
@@ -183,7 +211,12 @@ function getOrCreate(shareKey: string): Share {
 export async function refreshSharedMachinesList(shareKey: string): Promise<void> {
   const share = shares.get(shareKey);
   if (!share) return;
+  // An explicit refresh (user action, post-mutation reconcile) may retry once;
+  // a repeated refusal halts polling again.
+  const wasHalted = share.halted;
+  share.halted = false;
   await run(share, true);
+  if (wasHalted) arm(share);
 }
 
 export function useSharedMachinesList(