@anthusai/papyrus 0.0.0 → 1.0.0-next.1

package/components/dev-sandbox-editor-sign-in.tsx

@@ -0,0 +1,60 @@
+"use client";
+
+import { fetchAuthSession, signIn, signOut } from "aws-amplify/auth";
+import { configureAmplifyClient } from "./amplify-client-provider";
+import type { DevSandboxEditorAuth } from "../lib/dev-sandbox-editor-auth";
+
+const EDITOR_GROUPS = new Set(["editor", "admin"]);
+
+function readSessionGroups(session: Awaited<ReturnType<typeof fetchAuthSession>>): string[] {
+  const accessPayload = session.tokens?.accessToken?.payload ?? {};
+  const idPayload = session.tokens?.idToken?.payload ?? {};
+  const rawGroups = [
+    accessPayload["cognito:groups"],
+    accessPayload.groups,
+    idPayload["cognito:groups"],
+    idPayload.groups,
+  ];
+  const groups: string[] = [];
+  for (const value of rawGroups) {
+    if (typeof value === "string" && value.trim()) groups.push(value.trim());
+    else if (Array.isArray(value)) {
+      for (const entry of value) {
+        if (typeof entry === "string" && entry.trim()) groups.push(entry.trim());
+      }
+    }
+  }
+  return [...new Set(groups)];
+}
+
+function sessionHasEditorAccess(session: Awaited<ReturnType<typeof fetchAuthSession>>): boolean {
+  if (!session.tokens?.accessToken) return false;
+  return readSessionGroups(session).some((group) => EDITOR_GROUPS.has(group));
+}
+
+export async function ensureDevSandboxEditorSession(
+  credentials: DevSandboxEditorAuth | null | undefined,
+): Promise<void> {
+  if (!credentials) return;
+
+  configureAmplifyClient();
+
+  const existing = await fetchAuthSession();
+  if (sessionHasEditorAccess(existing)) return;
+
+  if (existing.tokens?.accessToken) {
+    try {
+      await signOut();
+    } catch {
+      // Continue into seed sign-in even if sign-out fails.
+    }
+  }
+
+  const result = await signIn({
+    username: credentials.username,
+    password: credentials.password,
+  });
+  if (!result.isSignedIn) return;
+
+  await fetchAuthSession({ forceRefresh: true });
+}

package/components/news-desk-client-provider.tsx

@@ -0,0 +1,211 @@
+"use client";
+
+import { Hub } from "aws-amplify/utils";
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
+import type { DevSandboxEditorAuth } from "../lib/dev-sandbox-editor-auth";
+import { ensureDevSandboxEditorSession } from "./dev-sandbox-editor-sign-in";
+import {
+  loadEditorAssignmentsData,
+  loadEditorDoctrineRecordsData,
+  loadEditorNewsDeskDashboard,
+  loadEditorResolvedAccessState,
+  loadEditorUserDirectoryData,
+} from "./news-desk-taxonomy-client";
+import {
+  beginAccessCheck,
+  beginAuthenticatedDeskHydration,
+  createInitialNewsDeskShellState,
+  patchDashboard,
+  resolveDashboardFailure,
+  resolveDashboardReady,
+  resolveForbidden,
+  resolveSignedOut,
+  type NewsDeskShellState,
+} from "../lib/news-desk-session";
+
+export type NewsDeskSearchTransition = {
+  href: string;
+  kind: "modal-to-serp";
+  requestKey: string;
+  submittedAt: number;
+};
+
+type NewsDeskClientContextValue = {
+  beginSearchTransition: (transition: NewsDeskSearchTransition) => void;
+  clearSearchTransition: () => void;
+  shell: NewsDeskShellState;
+  searchTransition: NewsDeskSearchTransition | null;
+  refreshDashboard: () => Promise<void>;
+  refreshAssignments: () => Promise<void>;
+  refreshDoctrineRecords: () => Promise<void>;
+  refreshUserDirectory: () => Promise<void>;
+};
+
+const NewsDeskClientContext = createContext<NewsDeskClientContextValue | null>(null);
+
+export function NewsDeskClientProvider({
+  children,
+  devSandboxEditorAuth = null,
+}: Readonly<{ children: React.ReactNode; devSandboxEditorAuth?: DevSandboxEditorAuth | null }>) {
+  const [shell, setShell] = useState<NewsDeskShellState>(() => createInitialNewsDeskShellState());
+  const [searchTransition, setSearchTransition] = useState<NewsDeskSearchTransition | null>(null);
+  const shellRef = useRef(shell);
+  const bootstrapSequenceRef = useRef(0);
+
+  useEffect(() => {
+    shellRef.current = shell;
+  }, [shell]);
+
+  const refreshDashboard = useCallback(async () => {
+    const sequence = ++bootstrapSequenceRef.current;
+    setShell((current) => beginAccessCheck(current));
+
+    try {
+      await ensureDevSandboxEditorSession(devSandboxEditorAuth);
+    } catch (error) {
+      console.error("[PapyrusDevAuth] Sandbox editor auto sign-in failed:", error);
+    }
+    if (bootstrapSequenceRef.current !== sequence) return;
+
+    const access = await loadEditorResolvedAccessState();
+    if (bootstrapSequenceRef.current !== sequence) return;
+
+    if (access.status === "signedOut") {
+      setShell((current) => resolveSignedOut(current, access.auth));
+      return;
+    }
+    if (access.status === "forbidden") {
+      setShell((current) => resolveForbidden(current, access.auth));
+      return;
+    }
+    if (access.status === "error") {
+      setShell((current) => resolveDashboardFailure(current, access.auth, access.error));
+      return;
+    }
+
+    setShell((current) => beginAuthenticatedDeskHydration(current, access.auth, { canManageUsers: access.isAdmin }));
+
+    try {
+      const dashboard = await loadEditorNewsDeskDashboard({ isAdmin: access.isAdmin });
+      if (bootstrapSequenceRef.current !== sequence) return;
+      setShell((current) => resolveDashboardReady(current, dashboard, access.auth, new Date().toISOString()));
+    } catch (error) {
+      if (bootstrapSequenceRef.current !== sequence) return;
+      if (isAuthorizationError(error)) {
+        setShell((current) => resolveForbidden(current, access.auth));
+        return;
+      }
+      setShell((current) => resolveDashboardFailure(
+        current,
+        access.auth,
+        error instanceof Error ? error.message : "Could not load Newsroom data.",
+      ));
+    }
+  }, [devSandboxEditorAuth]);
+
+  const refreshAssignments = useCallback(async () => {
+    try {
+      const assignmentState = await loadEditorAssignmentsData();
+      setShell((current) => patchDashboard(
+        current,
+        (dashboard) => ({
+          ...dashboard,
+          assignments: assignmentState.assignments,
+          assignmentEvents: assignmentState.assignmentEvents,
+        }),
+        new Date().toISOString(),
+      ));
+    } catch (error) {
+      const auth = shellRef.current.auth;
+      setShell((current) => resolveDashboardFailure(
+        current,
+        auth,
+        error instanceof Error ? error.message : "Could not refresh assignments.",
+      ));
+    }
+  }, []);
+
+  const refreshDoctrineRecords = useCallback(async () => {
+    try {
+      const doctrineRecords = await loadEditorDoctrineRecordsData({ dashboard: shellRef.current.dashboard });
+      setShell((current) => patchDashboard(
+        current,
+        (dashboard) => ({
+          ...dashboard,
+          doctrineRecords,
+        }),
+        new Date().toISOString(),
+      ));
+    } catch (error) {
+      const auth = shellRef.current.auth;
+      setShell((current) => resolveDashboardFailure(
+        current,
+        auth,
+        error instanceof Error ? error.message : "Could not refresh doctrine records.",
+      ));
+    }
+  }, []);
+
+  const refreshUserDirectory = useCallback(async () => {
+    if (!shellRef.current.dashboard?.canManageUsers) return;
+    try {
+      const userDirectory = await loadEditorUserDirectoryData();
+      setShell((current) => patchDashboard(
+        current,
+        (dashboard) => ({
+          ...dashboard,
+          userDirectory,
+        }),
+        new Date().toISOString(),
+      ));
+    } catch (error) {
+      const auth = shellRef.current.auth;
+      setShell((current) => resolveDashboardFailure(
+        current,
+        auth,
+        error instanceof Error ? error.message : "Could not refresh the user directory.",
+      ));
+    }
+  }, []);
+
+  useEffect(() => {
+    void refreshDashboard();
+    const unsubscribe = Hub.listen("auth", ({ payload }) => {
+      if (payload.event === "signedOut") {
+        bootstrapSequenceRef.current += 1;
+        setShell((current) => resolveSignedOut(current, { status: "signedOut", label: "Signed out" }));
+        return;
+      }
+      if (
+        payload.event === "signedIn" ||
+        payload.event === "signInWithRedirect" ||
+        payload.event === "signInWithRedirect_failure"
+      ) {
+        void refreshDashboard();
+      }
+    });
+    return () => unsubscribe();
+  }, [refreshDashboard]);
+
+  const value = useMemo<NewsDeskClientContextValue>(() => ({
+    beginSearchTransition: (transition) => setSearchTransition(transition),
+    clearSearchTransition: () => setSearchTransition(null),
+    shell,
+    searchTransition,
+    refreshDashboard,
+    refreshAssignments,
+    refreshDoctrineRecords,
+    refreshUserDirectory,
+  }), [refreshAssignments, refreshDashboard, refreshDoctrineRecords, refreshUserDirectory, searchTransition, shell]);
+
+  return <NewsDeskClientContext.Provider value={value}>{children}</NewsDeskClientContext.Provider>;
+}
+
+function isAuthorizationError(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : String(error ?? "");
+  return /not authorized|unauthorized|access denied|forbidden/i.test(message);
+}
+
+export function useOptionalNewsDeskClient() {
+  return useContext(NewsDeskClientContext);
+}

package/components/news-desk-page.tsx

@@ -0,0 +1,119 @@
+import { cookies } from "next/headers";
+import { NewsDeskWorkspace, type NewsDeskTab } from "./topic-steering-workspace";
+import {
+  createDemoCategorySteeringDashboard,
+  loadAnalysisProfileSummaries,
+  loadCategorySteeringDashboard,
+  loadConfiguredCorpusSummaries,
+} from "../lib/category-repository";
+import {
+  BRAND_OVERRIDE_COOKIE,
+  getBrandAnalysisProfilesPath,
+  getBrandNewsroomSectionsConfigPath,
+  getBrandSteeringConfigPath,
+  resolveActiveSiteBrand,
+} from "../lib/site-brand-tenant";
+
+export type NewsDeskPageProps = {
+  sectionPageId?: string | null;
+  section?: string | string[] | null;
+  selectionPath?: string[] | null;
+  searchParams?: Promise<{
+    demo?: string | string[];
+    section?: string | string[];
+    tab?: string | string[];
+    panel?: string | string[];
+    reference?: string | string[];
+    category?: string | string[];
+    node?: string | string[];
+    message?: string | string[];
+    assignment?: string | string[];
+    user?: string | string[];
+    item?: string | string[];
+    q?: string | string[];
+    anchorKind?: string | string[];
+    anchorId?: string | string[];
+    anchorLineageId?: string | string[];
+    maxTokens?: string | string[];
+    from?: string | string[];
+    view?: string | string[];
+    proposal?: string | string[];
+  }>;
+};
+
+export async function NewsDeskPage({ section: routeSection, sectionPageId, selectionPath, searchParams }: NewsDeskPageProps) {
+  const resolvedSearchParams = await searchParams;
+  const initialTab = parseNewsDeskTab(routeSection ?? getSearchParam(resolvedSearchParams, "section"), getSearchParam(resolvedSearchParams, "tab"));
+  const routeSelection = parseRouteSelection(initialTab, selectionPath);
+  const initialSelection = {
+    assignment: routeSelection.assignment ?? getFirstSearchParam(resolvedSearchParams, "assignment"),
+    reference: routeSelection.reference ?? getFirstSearchParam(resolvedSearchParams, "reference"),
+    category: routeSelection.category ?? getFirstSearchParam(resolvedSearchParams, "category"),
+    node: getFirstSearchParam(resolvedSearchParams, "node"),
+    message: routeSelection.message ?? getFirstSearchParam(resolvedSearchParams, "message"),
+    user: getFirstSearchParam(resolvedSearchParams, "user"),
+    item: getFirstSearchParam(resolvedSearchParams, "item"),
+    panel: routeSelection.panel ?? getFirstSearchParam(resolvedSearchParams, "panel"),
+    searchQuery: getFirstSearchParam(resolvedSearchParams, "q"),
+    searchAnchorKind: getFirstSearchParam(resolvedSearchParams, "anchorKind"),
+    searchAnchorId: getFirstSearchParam(resolvedSearchParams, "anchorId"),
+    searchAnchorLineageId: getFirstSearchParam(resolvedSearchParams, "anchorLineageId"),
+    searchMaxTokens: getFirstSearchParam(resolvedSearchParams, "maxTokens"),
+    searchFrom: getFirstSearchParam(resolvedSearchParams, "from"),
+    assignmentView: getFirstSearchParam(resolvedSearchParams, "view"),
+    forumThread: routeSelection.forumThread,
+    proposal: getFirstSearchParam(resolvedSearchParams, "proposal"),
+  };
+  const useDemoDashboard = getFirstSearchParam(resolvedSearchParams, "demo") === "1";
+  const brandOverride = (await cookies()).get(BRAND_OVERRIDE_COOKIE)?.value ?? null;
+  const brand = resolveActiveSiteBrand(brandOverride);
+  const analysisProfiles = await loadAnalysisProfileSummaries(getBrandAnalysisProfilesPath(brand));
+  const configuredCorpora = await loadConfiguredCorpusSummaries(getBrandSteeringConfigPath(brand));
+  const dashboard = useDemoDashboard
+    ? createDemoCategorySteeringDashboard(brand.id, getBrandNewsroomSectionsConfigPath(brand))
+    : await loadCategorySteeringDashboard();
+  return <NewsDeskWorkspace analysisProfiles={analysisProfiles} configuredCorpora={configuredCorpora} dashboard={dashboard} initialSelection={initialSelection} initialTab={initialTab} sectionPageId={sectionPageId ?? null} />;
+}
+
+function parseRouteSelection(tab: NewsDeskTab, selectionPath: string[] | null | undefined): { assignment?: string | null; category?: string | null; message?: string | null; panel?: string | null; reference?: string | null; forumThread?: string | null } {
+  const segments = (selectionPath ?? []).map((segment) => decodeURIComponent(segment)).filter(Boolean);
+  if (!segments.length) return {};
+  if (segments[0] === "forum" && segments[1]) return { forumThread: segments[1] };
+  if (tab === "administration") return { panel: segments[0] ?? null };
+  if (tab === "topics") return { category: segments[1] ?? segments[0] ?? null };
+  if (tab === "references") return { reference: segments[0] ?? null };
+  if (tab === "concepts") return { category: segments[0] ?? null };
+  if (tab === "messages") {
+    if (segments[0] === "forum" && segments[1]) return { forumThread: segments[1] };
+    return { message: segments[0] ?? null };
+  }
+  if (tab === "insights") return { forumThread: segments[0] ?? null };
+  if (tab === "assignments") return { assignment: segments[0] ?? null };
+  if (tab === "overview" && segments[0] === "forum" && segments[1]) return { forumThread: segments[1] };
+  return {};
+}
+
+function getSearchParam(searchParams: unknown, key: string): string | string[] | null | undefined {
+  if (searchParams instanceof URLSearchParams) return searchParams.get(key);
+  if (!searchParams || typeof searchParams !== "object") return undefined;
+  return (searchParams as Record<string, string | string[] | undefined>)[key];
+}
+
+function getFirstSearchParam(searchParams: unknown, key: string): string | null {
+  const value = getSearchParam(searchParams, key);
+  const first = Array.isArray(value) ? value[0] : value;
+  return typeof first === "string" && first.trim() ? first.trim() : null;
+}
+
+function parseNewsDeskTab(sectionValue: string | string[] | null | undefined, legacyTabValue: string | string[] | null | undefined): NewsDeskTab {
+  const section = Array.isArray(sectionValue) ? sectionValue[0] : sectionValue;
+  const legacyTab = Array.isArray(legacyTabValue) ? legacyTabValue[0] : legacyTabValue;
+  const rawValue = section ?? (legacyTab === "categories" ? "topics" : legacyTab);
+  const value = rawValue === "users" || rawValue === "doctrine"
+    ? "administration"
+    : rawValue === "desks"
+      ? "topics"
+      : rawValue;
+  if (value === "administration" || value === "topics" || value === "concepts" || value === "references" || value === "insights" || value === "messages" || value === "assignments" || value === "search") return value;
+  return "overview";
+}