@agent-native/core 0.164.3 → 0.164.11

package/corpus/templates/slides/app/routes/access-request.approve.tsx

@@ -0,0 +1,250 @@
+import { callAction, useSession } from "@agent-native/core/client/hooks";
+import { useT } from "@agent-native/core/client/i18n";
+import { buildSignInReturnHref } from "@agent-native/core/client/ui";
+import { IconAlertTriangle, IconCheck, IconLock } from "@tabler/icons-react";
+import { useEffect, useMemo, useState } from "react";
+import { Link, useSearchParams } from "react-router";
+
+import { Button } from "@/components/ui/button";
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
+import { Skeleton } from "@/components/ui/skeleton";
+import enMessages from "@/i18n/en-US";
+
+import {
+  deckAccessApprovalContinuationPath,
+  deckAccessApprovalSessionKey,
+} from "../../shared/deck-access";
+
+interface ApprovalResult {
+  ok: true;
+  alreadyAllowed: boolean;
+  requesterEmail: string;
+  deckId: string;
+  deckTitle: string;
+  shareId: string;
+  message: string;
+}
+
+type ApprovalState =
+  | { kind: "loading" }
+  | { kind: "sign-in" }
+  | { kind: "success"; result: ApprovalResult }
+  | { kind: "error"; message: string };
+
+export function meta() {
+  return [{ title: enMessages.deckEditor.privateDeckTitle }];
+}
+
+export default function ApproveDeckAccessRequestRoute() {
+  const t = useT();
+  const [searchParams] = useSearchParams();
+  const { session, isLoading: sessionLoading } = useSession();
+  const deckId = searchParams.get("deckId") ?? "";
+  const approvalTokenFromUrl = searchParams.get("token") ?? "";
+  const approvalTokenStorageKey = deckAccessApprovalSessionKey(deckId);
+  const [approvalToken, setApprovalToken] = useState(() => {
+    if (approvalTokenFromUrl) return approvalTokenFromUrl;
+    if (typeof window === "undefined" || !deckId) return "";
+    try {
+      return sessionStorage.getItem(approvalTokenStorageKey) ?? "";
+    } catch {
+      // coercion-ok: unavailable tab storage is an absent continuation.
+      return "";
+    }
+  });
+  const [state, setState] = useState<ApprovalState>({ kind: "loading" });
+
+  useEffect(() => {
+    if (!deckId) {
+      setApprovalToken("");
+      return;
+    }
+    if (!approvalTokenFromUrl) {
+      try {
+        setApprovalToken(sessionStorage.getItem(approvalTokenStorageKey) ?? "");
+      } catch {
+        setApprovalToken("");
+      }
+      return;
+    }
+    try {
+      sessionStorage.setItem(approvalTokenStorageKey, approvalTokenFromUrl);
+    } catch {
+      // coercion-ok: never fall back to putting the bearer token in the URL.
+      // Session storage may be unavailable in hardened browser contexts.
+    }
+    setApprovalToken(approvalTokenFromUrl);
+
+    // The email link must contain the capability, but it should not remain in
+    // the address bar or be copied into the sign-in continuation URL.
+    const params = new URLSearchParams(window.location.search);
+    params.delete("token");
+    const nextSearch = params.toString();
+    window.history.replaceState(
+      window.history.state,
+      "",
+      `${window.location.pathname}${nextSearch ? `?${nextSearch}` : ""}${window.location.hash}`,
+    );
+  }, [approvalTokenFromUrl, approvalTokenStorageKey, deckId]);
+
+  const signInReturnTo = useMemo(
+    () => deckAccessApprovalContinuationPath(deckId),
+    [deckId],
+  );
+
+  useEffect(() => {
+    if (sessionLoading) return;
+
+    let cancelled = false;
+    if (!session?.email) {
+      setState({ kind: "sign-in" });
+      return () => {
+        cancelled = true;
+      };
+    }
+    if (!deckId || !approvalToken) {
+      setState({
+        kind: "error",
+        message: t("deckEditor.accessApprovalInvalid"),
+      });
+      return () => {
+        cancelled = true;
+      };
+    }
+
+    setState({ kind: "loading" });
+    void callAction<ApprovalResult>("approve-deck-access-request", {
+      deckId,
+      approvalToken,
+    })
+      .then((result) => {
+        try {
+          sessionStorage.removeItem(approvalTokenStorageKey);
+        } catch {
+          // coercion-ok: cleanup failure cannot authorize or expose the token.
+          // Session storage may be unavailable in hardened browser contexts.
+        }
+        if (!cancelled) setState({ kind: "success", result });
+      })
+      .catch((error: unknown) => {
+        if (cancelled) return;
+        setState({
+          kind: "error",
+          message:
+            error instanceof Error
+              ? error.message
+              : t("deckEditor.accessApprovalInvalid"),
+        });
+      });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [
+    approvalToken,
+    approvalTokenStorageKey,
+    deckId,
+    session?.email,
+    sessionLoading,
+    t,
+  ]);
+
+  const signInHref = buildSignInReturnHref({ returnTo: signInReturnTo });
+
+  return (
+    <div className="flex min-h-screen items-center justify-center bg-background px-6 py-12 text-foreground">
+      <Card className="w-full max-w-md">
+        <CardHeader>
+          <CardTitle className="flex items-center gap-2">
+            <IconLock
+              className="size-5 text-muted-foreground"
+              aria-hidden="true"
+            />
+            {state.kind === "success"
+              ? state.result.alreadyAllowed
+                ? t("deckEditor.accessApprovalAlreadyTitle")
+                : t("deckEditor.accessApprovalTitle")
+              : state.kind === "error"
+                ? t("deckEditor.accessApprovalErrorTitle")
+                : state.kind === "sign-in"
+                  ? t("deckEditor.accessApprovalSignInTitle")
+                  : t("deckEditor.accessApprovalLoading")}
+          </CardTitle>
+        </CardHeader>
+        <CardContent aria-live="polite">
+          {state.kind === "loading" ? (
+            <div className="space-y-3 py-2">
+              <Skeleton className="h-4 w-full" />
+              <Skeleton className="h-4 w-4/5" />
+            </div>
+          ) : state.kind === "sign-in" ? (
+            <div className="space-y-4">
+              <p className="text-sm text-muted-foreground">
+                {t("deckEditor.accessApprovalSignInMessage")}
+              </p>
+              <Button asChild>
+                <a
+                  href={signInHref}
+                  onClick={() => {
+                    if (!approvalToken) return;
+                    try {
+                      sessionStorage.setItem(
+                        approvalTokenStorageKey,
+                        approvalToken,
+                      );
+                    } catch {
+                      // coercion-ok: never fall back to putting the bearer token in the URL.
+                      // Session storage may be unavailable in hardened browser contexts.
+                    }
+                  }}
+                >
+                  {t("deckEditor.accessApprovalSignIn")}
+                </a>
+              </Button>
+            </div>
+          ) : state.kind === "error" ? (
+            <div className="space-y-4">
+              <div className="flex items-start gap-3 rounded-md border border-destructive/30 bg-destructive/10 p-3 text-sm text-destructive">
+                <IconAlertTriangle
+                  className="mt-0.5 size-4 shrink-0"
+                  aria-hidden="true"
+                />
+                <span>{state.message}</span>
+              </div>
+              {deckId ? (
+                <Button asChild variant="outline">
+                  <Link to={`/deck/${encodeURIComponent(deckId)}`}>
+                    {t("deckEditor.accessApprovalOpenDeck")}
+                  </Link>
+                </Button>
+              ) : null}
+            </div>
+          ) : (
+            <div className="space-y-4">
+              <div className="flex items-start gap-3 rounded-md border border-primary/30 bg-primary/10 p-3 text-sm">
+                <IconCheck
+                  className="mt-0.5 size-4 shrink-0 text-primary"
+                  aria-hidden="true"
+                />
+                <span>
+                  {state.result.alreadyAllowed
+                    ? t("deckEditor.accessApprovalAlreadyMessage", {
+                        email: state.result.requesterEmail,
+                      })
+                    : t("deckEditor.accessApprovalMessage", {
+                        email: state.result.requesterEmail,
+                      })}
+                </span>
+              </div>
+              <Button asChild variant="outline">
+                <Link to={`/deck/${encodeURIComponent(state.result.deckId)}`}>
+                  {t("deckEditor.accessApprovalOpenDeck")}
+                </Link>
+              </Button>
+            </div>
+          )}
+        </CardContent>
+      </Card>
+    </div>
+  );
+}

package/corpus/templates/slides/server/db/schema.ts

@@ -93,3 +93,11 @@ export const deckEvents = table("deck_events", {
   createdBy: text("created_by").notNull().default("human"),
   createdAt: text("created_at").notNull().default(now()),
 });
+
+// One durable bucket per deck keeps anonymous access-request throttling
+// consistent across serverless instances and cold starts.
+export const deckAccessRequestLimits = table("deck_access_request_limits", {
+  deckId: text("deck_id").primaryKey(),
+  windowStartedAt: text("window_started_at").notNull(),
+  requestCount: integer("request_count").notNull().default(0),
+});

package/corpus/templates/slides/server/lib/access-request-email.ts

@@ -0,0 +1,36 @@
+import { emailStrong, renderEmail } from "@agent-native/core/server";
+
+export const SLIDES_DECK_ACCESS_REQUEST_EMAIL_ID = "slides.deck-access-request";
+
+function cleanSubjectPart(value: string): string {
+  return value.replace(/[\r\n]+/g, " ").trim();
+}
+
+export function renderDeckAccessRequestEmail(input: {
+  requesterName: string;
+  requesterEmail: string;
+  deckTitle: string;
+  url: string;
+  allowAccessUrl: string;
+}) {
+  const subject = `Access request for "${cleanSubjectPart(input.deckTitle)}"`;
+  return {
+    subject,
+    ...renderEmail({
+      brandName: "Slides",
+      preheader: subject,
+      heading: "Access requested",
+      paragraphs: [
+        `${emailStrong(input.requesterName)} (${emailStrong(input.requesterEmail)}) requested access to ${emailStrong(input.deckTitle)}.`,
+        "Select Allow access to add them to this deck's sharing list. You can also open the deck to review sharing first.",
+      ],
+      cta: { label: "Allow access", url: input.allowAccessUrl },
+      secondaryCta: { label: "Open deck", url: input.url },
+      closingParagraphs: [
+        "This approval link expires in 7 days and requires you to be signed in as a deck owner or admin.",
+      ],
+      footer:
+        "You received this because you own this deck. If you do not recognize the requester, you can ignore this email.",
+    }),
+  };
+}

package/corpus/templates/slides/server/lib/emails.ts

@@ -10,6 +10,10 @@ import {
   getTransactionalEmail,
 } from "@agent-native/core/email-catalog";
 
+import {
+  renderDeckAccessRequestEmail,
+  SLIDES_DECK_ACCESS_REQUEST_EMAIL_ID,
+} from "./access-request-email.js";
 import { renderDeckCommentEmail } from "./comment-notifications.js";
 
 export const SLIDES_DECK_COMMENT_EMAIL_ID = "slides.deck-comment";
@@ -42,4 +46,26 @@ export function registerSlidesEmails(): void {
         isReply: false,
       }),
   });
+
+  defineTransactionalEmail({
+    id: SLIDES_DECK_ACCESS_REQUEST_EMAIL_ID,
+    name: "Deck access request",
+    trigger:
+      "A signed-in viewer requests access to a private Slides deck. One request is recorded per viewer and deck.",
+    recipientLabel: "Deck owner",
+    recipient:
+      "The owner of the private deck. The in-app notification is stored even when email delivery is unavailable.",
+    senderLabel: "Agent-Native Slides",
+    sender:
+      "The configured default sender. This call site sets no custom from or app sender.",
+    preview: () =>
+      renderDeckAccessRequestEmail({
+        requesterName: "Sam Rivera",
+        requesterEmail: "sam.rivera@example.com",
+        deckTitle: "Quarterly review",
+        url: "https://example.com/deck/deck_sample",
+        allowAccessUrl:
+          "https://example.com/access-request/approve?deckId=deck_sample&token=preview-token",
+      }),
+  });
 }

package/corpus/templates/slides/server/plugins/agent-chat.ts

@@ -56,6 +56,13 @@ export default createAgentChatPlugin({
     const authContext = await resolveSlidesRequestAuthContext(event);
     return authContext.orgId === undefined ? null : authContext.orgId;
   },
+  // Guest access requests authenticate with a signed deck capability and the
+  // requester email, so this action must reach its own validation without a
+  // browser session.
+  actionRoutePublicPaths: [
+    "/_agent-native/actions/get-deck-access-status",
+    "/_agent-native/actions/request-deck-access",
+  ],
   prepareRequest: prepareSlidesChatAttachments,
   systemPrompt: `You are an AI deck assistant. You create, edit, import, export, style, share, and navigate decks through actions and shared application state. For a newly created presentation, use create-deck with slides: [] only when you are creating the deck yourself, then add-slide sequentially with full rendered HTML. The legacy generate-slides-ai action returns Markdown drafts and is not part of the persisted presentation workflow. When speaker notes are requested, keep presenter-only text in each slide's notes field rather than the slide HTML, and preserve notes during source-preserving edits.
 

package/corpus/templates/slides/server/plugins/db.ts

@@ -252,6 +252,56 @@ export const runSlidesMigrations = runMigrations(
   );
   CREATE INDEX IF NOT EXISTS deck_events_deck_created_idx ON deck_events (deck_id, created_at)`,
     },
+    {
+      version: 23,
+      name: "slides-deck-access-request-rate-limits",
+      sql: `CREATE TABLE IF NOT EXISTS deck_access_request_limits (
+    deck_id TEXT PRIMARY KEY,
+    window_started_at TEXT NOT NULL,
+    request_count INTEGER NOT NULL DEFAULT 0
+  )`,
+    },
+    {
+      version: 24,
+      name: "slides-deck-shares-user-principal-unique",
+      // Reconcile legacy rows before adding the constraint. Older databases
+      // could contain case variants or concurrent duplicate user shares, and
+      // CREATE UNIQUE INDEX would otherwise fail before this migration is
+      // recorded. Keep the strongest grant; id/created_at make equal-role
+      // survivors deterministic, and lower the retained principal so the
+      // repaired row is canonical as well as uniquely indexed.
+      sql: `DELETE FROM deck_shares
+WHERE principal_type = 'user'
+  AND id NOT IN (
+    SELECT id
+    FROM (
+      SELECT id,
+        ROW_NUMBER() OVER (
+          PARTITION BY resource_id, LOWER(principal_id)
+          ORDER BY CASE LOWER(role)
+            WHEN 'owner' THEN 5
+            WHEN 'admin' THEN 4
+            WHEN 'editor' THEN 3
+            WHEN 'commenter' THEN 2
+            WHEN 'viewer' THEN 1
+            ELSE 0
+          END DESC,
+          created_at ASC,
+          id ASC
+        ) AS row_number
+      FROM deck_shares
+      WHERE principal_type = 'user'
+    ) AS ranked
+    WHERE row_number = 1
+  );
+UPDATE deck_shares
+SET principal_id = LOWER(principal_id)
+WHERE principal_type = 'user'
+  AND principal_id <> LOWER(principal_id);
+CREATE UNIQUE INDEX IF NOT EXISTS deck_shares_resource_user_principal_uidx
+ON deck_shares (resource_id, LOWER(principal_id))
+WHERE principal_type = 'user'`,
+    },
   ],
   { table: "slides_migrations" },
 );

package/corpus/templates/slides/shared/deck-access.ts

@@ -0,0 +1,31 @@
+/** Short-lived capability used by a private deck viewer to request access. */
+export const SLIDES_ACCESS_REQUEST_TOKEN_PREFIX = "slides-access-request";
+/** Capability used when the private-deck access probe is unavailable. */
+export const SLIDES_ACCESS_REQUEST_FALLBACK_TOKEN_PREFIX =
+  "slides-access-request-fallback";
+export const SLIDES_ACCESS_REQUEST_TOKEN_TTL_SECONDS = 10 * 60;
+
+/** Signed capability used by an owner to approve a private deck access request. */
+export const SLIDES_ACCESS_APPROVAL_TOKEN_PREFIX = "slides-access-approval";
+export const SLIDES_ACCESS_APPROVAL_TOKEN_TTL_SECONDS = 7 * 24 * 60 * 60;
+export const SLIDES_ACCESS_APPROVAL_SESSION_KEY_PREFIX =
+  "slides-access-approval-token:";
+
+/** Owner-only route used by the one-click approval button in access emails. */
+export function deckAccessApprovalPath(
+  deckId: string,
+  approvalToken: string,
+): string {
+  const params = new URLSearchParams({ deckId, token: approvalToken });
+  return `/access-request/approve?${params.toString()}`;
+}
+
+/** Token-free continuation used after the approver signs in. */
+export function deckAccessApprovalContinuationPath(deckId: string): string {
+  return `/access-request/approve?${new URLSearchParams({ deckId }).toString()}`;
+}
+
+/** Tab-scoped key for carrying an approval token across the sign-in redirect. */
+export function deckAccessApprovalSessionKey(deckId: string): string {
+  return `${SLIDES_ACCESS_APPROVAL_SESSION_KEY_PREFIX}${encodeURIComponent(deckId)}`;
+}

package/dist/a2a/artifact-response.d.ts

@@ -9,6 +9,7 @@ export interface A2AArtifactResponseOptions {
     includeReferencedArtifacts?: boolean;
     includePersistedArtifactMarker?: boolean;
     persistedArtifactSecret?: string;
+    delegatedTaskId?: string;
 }
 export interface GuardedA2AArtifactResponse {
     text: string;
@@ -16,6 +17,7 @@ export interface GuardedA2AArtifactResponse {
 }
 export interface A2AArtifactIdentityOptions {
     persistedArtifactSecrets?: readonly string[];
+    expectedDelegatedTaskId?: string;
 }
 export interface A2AArtifactIdentity {
     resourceType: "document" | "deck" | "dashboard" | "analysis" | "image" | "design" | "monitor" | "form";
@@ -24,6 +26,48 @@ export interface A2AArtifactIdentity {
     titleAtAction?: string;
     url?: string;
 }
+export interface A2APersistedMutationReceipt {
+    receiptId: string;
+    sourceAction: string;
+    operation: string;
+    outcome: string;
+    target: {
+        authorityScopeKind: "personal" | "organization";
+        authorityScopeId: string;
+        spaceId: string;
+        databaseId: string;
+        databaseDocumentId: string;
+        itemId?: string;
+        rowDocumentId?: string;
+        propertyId?: string;
+    };
+    row: {
+        itemId?: string;
+        documentId: string;
+        urlPath: string;
+    };
+    idempotency: {
+        key: string;
+        result: "applied" | "replayed";
+        payloadDigest: string;
+    };
+    revisions: {
+        before?: string | null;
+        after?: string;
+        rowBefore?: string;
+        rowAfter?: string;
+        fieldBefore?: number;
+        fieldAfter?: number;
+    };
+    affected?: {
+        title?: boolean;
+        propertyIds?: string[];
+        blockIds?: string[];
+        deletedBlockIds?: string[];
+        order?: string[];
+    };
+    readbackVerified: true;
+}
 export declare function stripA2APersistedArtifactMarkers(text: string): string;
 /**
  * Extract a compact, verified identity ledger from successful artifact tools.
@@ -31,6 +75,12 @@ export declare function stripA2APersistedArtifactMarkers(text: string): string;
  * long-lived thread context and stable even when a resource is later renamed.
  */
 export declare function extractA2AArtifactIdentities(results: A2AToolResultSummary[], options?: A2AArtifactIdentityOptions): A2AArtifactIdentity[];
+/**
+ * Extract bounded, read-back-verified mutation receipts. Nested agent results
+ * are accepted only through the signed persisted ledger.
+ */
+export declare function extractA2APersistedMutationReceipts(results: A2AToolResultSummary[], options?: A2AArtifactIdentityOptions): A2APersistedMutationReceipt[];
+export declare function appendA2APersistedMutationReceipts(text: string, toolResults: A2AToolResultSummary[], options?: A2AArtifactResponseOptions): string;
 export declare function guardA2AArtifactResponse(responseText: string, toolResults: A2AToolResultSummary[], options?: A2AArtifactResponseOptions): GuardedA2AArtifactResponse;
 export declare function appendA2AArtifactLinks(responseText: string, toolResults: A2AToolResultSummary[], options?: A2AArtifactResponseOptions): string;
 export declare function buildA2ARecoverableArtifactMessage(toolResults: A2AToolResultSummary[], options?: A2AArtifactResponseOptions): string | null;