@agent-native/core 0.109.2 → 0.109.4

package/corpus/core/src/client/require-session.tsx

@@ -95,14 +95,31 @@ export function RequireSession({
   signedOut,
   bypass = false,
 }: RequireSessionProps) {
+  if (bypass) return <>{children}</>;
+  return (
+    <ResolvedSessionGate
+      fallback={fallback}
+      redirect={redirect}
+      signedOut={signedOut}
+    >
+      {children}
+    </ResolvedSessionGate>
+  );
+}
+
+function ResolvedSessionGate({
+  children,
+  fallback,
+  redirect = true,
+  signedOut,
+}: Omit<RequireSessionProps, "bypass">) {
   const { session, isLoading } = useSession();
   // Guard against firing the redirect more than once (effect re-runs, React
   // StrictMode double-invoke) — a second navigation while the first is in
   // flight is harmless but noisy.
   const redirectedRef = useRef(false);
 
-  const mustRedirect =
-    !bypass && !isLoading && !session && redirect && !isOnSignInPage();
+  const mustRedirect = !isLoading && !session && redirect && !isOnSignInPage();
 
   useEffect(() => {
     if (!mustRedirect) return;
@@ -114,7 +131,6 @@ export function RequireSession({
     window.location.replace(buildSignInReturnHref());
   }, [mustRedirect]);
 
-  if (bypass) return <>{children}</>;
   // Still resolving, or redirect already in flight: show the loading fallback
   // rather than flashing app chrome the visitor can't use.
   if (isLoading) return <>{fallback ?? <DefaultSpinner />}</>;

package/corpus/core/src/client/rich-markdown-editor/index.ts

@@ -1,73 +1,58 @@
-export {
-  createSharedEditorExtensions,
-  MARKDOWN_DIALECT_CONFIG,
-  type RichMarkdownDialect,
-  type RichMarkdownEditorPreset,
-  type RichMarkdownCollabUser,
-  type SharedEditorCollab,
-  type SharedEditorFeatures,
-  type CreateSharedEditorExtensionsOptions,
-} from "./extensions.js";
-export {
-  useCollabReconcile,
-  getEditorMarkdown,
-  RICH_MARKDOWN_PROGRAMMATIC_TRANSACTION,
-  type UseCollabReconcileOptions,
-  type UseCollabReconcileResult,
-} from "./useCollabReconcile.js";
 export {
   applyDocSurgically,
+  BubbleToolbar,
+  buildDefaultBubbleItems,
+  createCodeBlockNode,
+  createImageExtension,
+  createImageSlashCommand,
+  createRichMarkdownExtensions,
+  createSharedEditorExtensions,
+  DEFAULT_CODE_LANGUAGES,
+  DEFAULT_DRAG_HANDLE_WRAPPER_SELECTOR,
+  DEFAULT_SLASH_COMMANDS,
   defaultParseValue,
   diffTopLevel,
-  type TopLevelDiff,
-} from "./surgical-apply.js";
-export {
-  SlashCommandMenu,
-  DEFAULT_SLASH_COMMANDS,
-  createImageSlashCommand,
-  type SlashCommandItem,
-  type SlashCommandMenuProps,
-} from "./SlashCommandMenu.js";
-export {
-  SharedImage,
-  createImageExtension,
+  DragHandle,
+  getEditorMarkdown,
+  gfmToProseJSON,
+  MARKDOWN_DIALECT_CONFIG,
   pickAndInsertImage,
-  type ImageUploadFn,
-  type SharedImageOptions,
-} from "./ImageExtension.js";
-export { uploadEditorImage } from "./uploadEditorImage.js";
-export {
-  BubbleToolbar,
-  buildDefaultBubbleItems,
+  proseJSONToGfm,
+  RICH_MARKDOWN_PROGRAMMATIC_TRANSACTION,
+  RichMarkdownEditor,
+  RunId,
+  RUN_ID_NODE_TYPES,
+  SharedImage,
+  SharedRichEditor,
+  SlashCommandMenu,
+  useCollabReconcile,
   type BubbleToolbarItem,
   type BubbleToolbarProps,
-} from "./BubbleToolbar.js";
-export {
-  SharedRichEditor,
-  type SharedRichEditorProps,
-} from "./SharedRichEditor.js";
-export {
-  createCodeBlockNode,
-  DEFAULT_CODE_LANGUAGES,
-  type CodeLanguageOption,
   type CodeBlockClassNames,
+  type CodeLanguageOption,
   type CreateCodeBlockNodeOptions,
-} from "./CodeBlockNode.js";
-export {
-  RichMarkdownEditor,
-  createRichMarkdownExtensions,
-  type RichMarkdownEditorProps,
   type CreateRichMarkdownExtensionsOptions,
-} from "./RichMarkdownEditor.js";
-export { RunId, RUN_ID_NODE_TYPES } from "./RunId.js";
-export { gfmToProseJSON, proseJSONToGfm } from "./gfmDoc.js";
-export {
-  DragHandle,
-  DEFAULT_DRAG_HANDLE_WRAPPER_SELECTOR,
+  type CreateSharedEditorExtensionsOptions,
   type DragHandleDropContext,
   type DragHandleDropPlacement,
   type DragHandleOptions,
-} from "./DragHandle.js";
+  type ImageUploadFn,
+  type RichMarkdownCollabUser,
+  type RichMarkdownDialect,
+  type RichMarkdownEditorPreset,
+  type RichMarkdownEditorProps,
+  type SharedEditorCollab,
+  type SharedEditorFeatures,
+  type SharedImageOptions,
+  type SharedRichEditorProps,
+  type SlashCommandItem,
+  type SlashCommandMenuProps,
+  type TopLevelDiff,
+  type UseCollabReconcileOptions,
+  type UseCollabReconcileResult,
+} from "@agent-native/toolkit/editor";
+
+export { uploadEditorImage } from "./uploadEditorImage.js";
 export {
   createRegistryBlockNode,
   RegistryBlockNodeView,

package/corpus/core/src/client/rich-markdown-editor/uploadEditorImage.ts

@@ -1,5 +1,6 @@
+import type { ImageUploadFn } from "@agent-native/toolkit/editor";
+
 import { callAction } from "../use-action.js";
-import type { ImageUploadFn } from "./ImageExtension.js";
 
 /**
  * Read a {@link File} as a base64 data URL (`data:image/...;base64,...`).

package/corpus/core/src/client/use-action.ts

@@ -27,6 +27,7 @@ import type {
   UseMutationOptions,
 } from "@tanstack/react-query";
 
+import { trackEvent } from "./analytics.js";
 import { agentNativePath } from "./api-path.js";
 import { getBrowserTabId } from "./browser-tab-id.js";
 import { ensureEmbedAuthFetchInterceptor } from "./embed-auth.js";
@@ -221,6 +222,10 @@ export interface ActionFetchOptions {
   includeRequestSource?: boolean;
 }
 
+type InternalActionFetchOptions = ActionFetchOptions & {
+  onResponse?: (response: Response) => void;
+};
+
 /**
  * Conservative per-document keepalive body budget. Browsers commonly enforce
  * an approximately 64 KiB aggregate limit across every in-flight keepalive
@@ -251,11 +256,11 @@ function utf8ByteLength(value: string): number {
   return bytes;
 }
 
-async function actionFetch<T>(
+async function performActionFetch<T>(
   name: string,
   method: string,
   params?: Record<string, any>,
-  options?: ActionFetchOptions,
+  options?: InternalActionFetchOptions,
 ): Promise<T> {
   ensureEmbedAuthFetchInterceptor();
   let url = `${ACTION_PREFIX}/${name}`;
@@ -332,6 +337,7 @@ async function actionFetch<T>(
   try {
     try {
       res = await fetch(url, init);
+      options?.onResponse?.(res);
     } catch (err) {
       if (timedOut) throwTimeout();
       // Caller-initiated cancellation — rethrow untouched so React Query
@@ -418,6 +424,143 @@ async function actionFetch<T>(
   return (data ?? (null as unknown)) as T;
 }
 
+function actionTelemetryNow(): number {
+  return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+
+function parseServerTiming(
+  response: Response | undefined,
+): Map<string, number> {
+  const timings = new Map<string, number>();
+  const value = response?.headers.get("server-timing");
+  if (!value) return timings;
+
+  for (const entry of value.split(",")) {
+    const [rawName, ...params] = entry.trim().split(";");
+    const name = rawName?.trim();
+    if (!name) continue;
+    const duration = params
+      .map((param) => /^dur=(.+)$/i.exec(param.trim())?.[1])
+      .find(Boolean);
+    const parsed = duration === undefined ? NaN : Number(duration);
+    if (Number.isFinite(parsed)) timings.set(name, parsed);
+  }
+  return timings;
+}
+
+function shouldTrackActionResponse(
+  error: unknown,
+  durationMs: number,
+  response: Response | undefined,
+): boolean {
+  if (error || durationMs >= 1_000) return true;
+  if (response && response.status >= 400 && response.status < 500) return true;
+  if (
+    /\bstartup(?:-db)?\s*;/i.test(response?.headers.get("server-timing") ?? "")
+  ) {
+    return true;
+  }
+  const raw = (import.meta.env as Record<string, string | undefined>)
+    ?.VITE_AGENT_NATIVE_ACTION_TELEMETRY_SAMPLE_RATE;
+  const parsed = raw === undefined ? 0.1 : Number(raw);
+  const rate = Number.isFinite(parsed) ? Math.max(0, Math.min(1, parsed)) : 0.1;
+  return Math.random() < rate;
+}
+
+async function actionFetch<T>(
+  name: string,
+  method: string,
+  params?: Record<string, any>,
+  options?: ActionFetchOptions,
+): Promise<T> {
+  const startedAt = actionTelemetryNow();
+  let response: Response | undefined;
+  let responseAt: number | undefined;
+  let error: unknown;
+
+  try {
+    return await performActionFetch<T>(name, method, params, {
+      ...options,
+      onResponse: (nextResponse) => {
+        response = nextResponse;
+        responseAt = actionTelemetryNow();
+      },
+    });
+  } catch (caught) {
+    error = caught;
+    throw caught;
+  } finally {
+    try {
+      const completedAt = actionTelemetryNow();
+      const durationMs = Math.max(0, completedAt - startedAt);
+      if (shouldTrackActionResponse(error, durationMs, response)) {
+        const ttfbMs =
+          responseAt === undefined
+            ? undefined
+            : Math.max(0, responseAt - startedAt);
+        const serverTiming = parseServerTiming(response);
+        const serverDurationMs = serverTiming.get("app");
+        const errorStatus = Number(
+          (error as { status?: unknown } | undefined)?.status,
+        );
+        const statusCode =
+          response?.status ??
+          (Number.isFinite(errorStatus) ? errorStatus : undefined);
+        const timedOut =
+          (error as { timedOut?: unknown } | undefined)?.timedOut === true;
+        const cancelled = options?.signal?.aborted === true && !timedOut;
+        const contentLength = Number(response?.headers.get("content-length"));
+
+        trackEvent("action.response", {
+          request_id:
+            response?.headers.get("x-agent-native-request-id") ?? undefined,
+          action: name,
+          method,
+          status_code: statusCode,
+          status_class:
+            statusCode === undefined
+              ? "network"
+              : `${Math.floor(statusCode / 100)}xx`,
+          success: !error,
+          outcome: !error
+            ? "success"
+            : timedOut
+              ? "timeout"
+              : cancelled
+                ? "cancelled"
+                : response
+                  ? "http-error"
+                  : "network-error",
+          duration_ms: Math.round(durationMs),
+          ttfb_ms: ttfbMs === undefined ? undefined : Math.round(ttfbMs),
+          body_ms:
+            ttfbMs === undefined ? undefined : Math.round(durationMs - ttfbMs),
+          server_duration_ms:
+            serverDurationMs === undefined
+              ? undefined
+              : Math.round(serverDurationMs),
+          network_overhead_ms:
+            ttfbMs === undefined || serverDurationMs === undefined
+              ? undefined
+              : Math.max(0, Math.round(ttfbMs - serverDurationMs)),
+          framework_ready_wait_ms: serverTiming.get("startup"),
+          db_operation_wall_ms: serverTiming.get("db"),
+          db_connect_total_ms: serverTiming.get("db-connect"),
+          db_slowest_operation_ms: serverTiming.get("db-slowest"),
+          startup_db_operation_wall_ms: serverTiming.get("startup-db"),
+          startup_db_connect_total_ms: serverTiming.get("startup-db-connect"),
+          response_bytes:
+            Number.isFinite(contentLength) && contentLength >= 0
+              ? contentLength
+              : undefined,
+        });
+      }
+    } catch {
+      // Performance telemetry must never change the action result.
+    }
+  }
+}
+
 /**
  * Imperatively call an action from browser/client code.
  *

package/corpus/core/src/client/use-session.ts

@@ -1,4 +1,4 @@
-import { useState, useEffect, useRef } from "react";
+import { useEffect, useState } from "react";
 
 import type { AuthSession } from "../server/auth.js";
 import { setSentryUser, trackSessionStatus } from "./analytics.js";
@@ -11,6 +11,65 @@ interface UseSessionResult {
   isLoading: boolean;
 }
 
+const SESSION_CACHE_TTL_MS = 30_000;
+const SESSION_RETRY_DELAY_MS = 1_000;
+let cachedSession: AuthSession | null | undefined;
+let cachedSessionAt = 0;
+let sessionRequest: Promise<AuthSession | null | undefined> | undefined;
+let trackedSessionIdentity: string | null | undefined;
+
+function hasFreshSessionCache(): boolean {
+  return (
+    cachedSession !== undefined &&
+    Date.now() - cachedSessionAt < SESSION_CACHE_TTL_MS
+  );
+}
+
+function publishSessionIdentity(session: AuthSession | null): void {
+  const identity = session?.userId ?? session?.email ?? null;
+  if (trackedSessionIdentity !== identity) {
+    trackedSessionIdentity = identity;
+    if (session) {
+      setSentryUser(
+        {
+          id: session.userId,
+          email: session.email,
+          username: session.name,
+        },
+        session.orgId ?? null,
+      );
+    } else {
+      setSentryUser(null, null);
+    }
+  }
+  trackSessionStatus(Boolean(session));
+}
+
+function fetchSharedSession(): Promise<AuthSession | null | undefined> {
+  if (hasFreshSessionCache()) return Promise.resolve(cachedSession ?? null);
+  if (sessionRequest) return sessionRequest;
+
+  sessionRequest = (async () => {
+    try {
+      const res = await fetch(agentNativePath("/_agent-native/auth/session"));
+      if (!res.ok) return undefined;
+
+      const data = await res.json();
+      const session = data.error ? null : (data as AuthSession);
+      cachedSession = session;
+      cachedSessionAt = Date.now();
+      publishSessionIdentity(session);
+      return session;
+    } catch {
+      return undefined;
+    }
+  })().finally(() => {
+    sessionRequest = undefined;
+  });
+
+  return sessionRequest;
+}
+
 /**
  * Client-side hook to get the current auth session.
  *
@@ -21,61 +80,33 @@ interface UseSessionResult {
  * Templates should use this instead of building their own auth context.
  */
 export function useSession(): UseSessionResult {
-  const [session, setSession] = useState<AuthSession | null>(null);
-  const [isLoading, setIsLoading] = useState(true);
-  const trackedRef = useRef(false);
+  const cached = hasFreshSessionCache() ? (cachedSession ?? null) : null;
+  const [session, setSession] = useState<AuthSession | null>(cached);
+  const [isLoading, setIsLoading] = useState(!hasFreshSessionCache());
 
   useEffect(() => {
     let cancelled = false;
+    let retryTimer: ReturnType<typeof setTimeout> | undefined;
 
-    async function fetchSession() {
-      let signedIn = false;
-      let resolved: AuthSession | null = null;
-      try {
-        const res = await fetch(agentNativePath("/_agent-native/auth/session"));
-        if (!res.ok) {
-          setSession(null);
-          return;
-        }
-        const data = await res.json();
-        if (!cancelled) {
-          // The endpoint returns { error: "..." } when not authenticated
-          if (data.error) {
-            setSession(null);
-          } else {
-            resolved = data as AuthSession;
-            setSession(resolved);
-            signedIn = true;
-          }
-        }
-      } catch {
-        if (!cancelled) setSession(null);
-      } finally {
-        if (!cancelled) {
-          setIsLoading(false);
-          if (resolved) {
-            setSentryUser(
-              {
-                id: resolved.userId,
-                email: resolved.email,
-                username: resolved.name,
-              },
-              resolved.orgId ?? null,
-            );
-          } else {
-            setSentryUser(null, null);
-          }
-          if (!trackedRef.current) {
-            trackedRef.current = true;
-            trackSessionStatus(signedIn);
-          }
-        }
+    const resolveSession = async () => {
+      const resolved = await fetchSharedSession();
+      if (cancelled) return;
+
+      if (resolved === undefined) {
+        retryTimer = setTimeout(() => {
+          void resolveSession();
+        }, SESSION_RETRY_DELAY_MS);
+        return;
       }
-    }
 
-    fetchSession();
+      setSession(resolved);
+      setIsLoading(false);
+    };
+
+    void resolveSession();
     return () => {
       cancelled = true;
+      if (retryTimer) clearTimeout(retryTimer);
     };
   }, []);