@agent-native/core 0.120.3 → 0.121.0

package/corpus/core/src/server/short-lived-token.ts

@@ -324,3 +324,125 @@ export function verifyRealtimeSubscribeToken(
     exp: claims.exp,
   };
 }
+
+// ── Gateway access-check tokens ──────────────────────────────────────────────
+//
+// The hosted gateway has no access to an app's shareable-resource registry, so
+// it cannot resolve sharee visibility itself. It signs one of these with the
+// app's per-project key and calls the app's `/_agent-native/can-see`, which runs
+// `resolveAccess` and answers. The full access query is bound into the token so
+// the app authenticates the params, not merely the caller.
+
+/** Payload `typ` discriminator for gateway access-check tokens. */
+export const GATEWAY_ACCESS_TOKEN_TYPE = "rt-access-check";
+/** Short TTL: minted per check, used immediately server-to-server. */
+const DEFAULT_GATEWAY_ACCESS_TTL_SECONDS = 60;
+
+/** Inputs for {@link signGatewayAccessToken}. */
+export interface GatewayAccessClaims {
+  projectId: string;
+  resourceType: string;
+  resourceId: string;
+  /** App end-user whose visibility of the resource is being checked. */
+  userEmail: string;
+  orgId?: string;
+  ttlSeconds?: number;
+}
+
+interface DecodedGatewayAccessClaims {
+  typ: string;
+  projectId: string;
+  resourceType: string;
+  resourceId: string;
+  userEmail: string;
+  orgId?: string;
+  exp: number;
+}
+
+/** Result of {@link verifyGatewayAccessToken}; on success carries the bound query. */
+export type GatewayAccessVerifyResult =
+  | {
+      ok: true;
+      projectId: string;
+      resourceType: string;
+      resourceId: string;
+      userEmail: string;
+      orgId?: string;
+    }
+  | { ok: false; reason: string };
+
+/** Mint a gateway access-check token, signed with the app's per-project `key`. */
+export function signGatewayAccessToken(
+  claims: GatewayAccessClaims,
+  key: string,
+): string {
+  if (!key) throw new Error("signGatewayAccessToken requires a key");
+  const ttl = claims.ttlSeconds ?? DEFAULT_GATEWAY_ACCESS_TTL_SECONDS;
+  const payload: DecodedGatewayAccessClaims = {
+    typ: GATEWAY_ACCESS_TOKEN_TYPE,
+    projectId: claims.projectId,
+    resourceType: claims.resourceType,
+    resourceId: claims.resourceId,
+    userEmail: claims.userEmail,
+    exp: Math.floor(Date.now() / 1000) + ttl,
+  };
+  if (claims.orgId) payload.orgId = claims.orgId;
+  const payloadStr = base64UrlEncode(JSON.stringify(payload));
+  return `${payloadStr}.${hmacB64(payloadStr, key)}`;
+}
+
+/** Verify a gateway access-check token against the app's per-project `key`. */
+export function verifyGatewayAccessToken(
+  token: string,
+  key: string,
+  expectedProjectId?: string,
+): GatewayAccessVerifyResult {
+  if (!key) return { ok: false, reason: "no_key" };
+  if (typeof token !== "string" || !token.includes(".")) {
+    return { ok: false, reason: "malformed" };
+  }
+  const [payloadStr, sig] = token.split(".", 2);
+  if (!payloadStr || !sig) return { ok: false, reason: "malformed" };
+
+  if (!timingSafeEqualB64(sig, hmacB64(payloadStr, key))) {
+    return { ok: false, reason: "bad_signature" };
+  }
+
+  let claims: DecodedGatewayAccessClaims;
+  try {
+    claims = JSON.parse(base64UrlDecode(payloadStr).toString("utf8"));
+  } catch {
+    return { ok: false, reason: "bad_payload" };
+  }
+
+  if (claims.typ !== GATEWAY_ACCESS_TOKEN_TYPE) {
+    return { ok: false, reason: "wrong_type" };
+  }
+  if (typeof claims.exp !== "number")
+    return { ok: false, reason: "bad_payload" };
+  if (claims.exp * 1000 < Date.now()) return { ok: false, reason: "expired" };
+  if (
+    !claims.projectId ||
+    !claims.resourceType ||
+    !claims.resourceId ||
+    !claims.userEmail
+  ) {
+    return { ok: false, reason: "bad_payload" };
+  }
+  // Optional channel binding, mirroring verifyRealtimeSubscribeToken. The
+  // per-project key already scopes verification to one app; this is belt-and-
+  // suspenders for a future multi-tenant secret store. Skipped when the caller
+  // can't cheaply resolve its own project id (scoped-secret apps).
+  if (expectedProjectId && claims.projectId !== expectedProjectId) {
+    return { ok: false, reason: "wrong_project" };
+  }
+
+  return {
+    ok: true,
+    projectId: claims.projectId,
+    resourceType: claims.resourceType,
+    resourceId: claims.resourceId,
+    userEmail: claims.userEmail,
+    orgId: claims.orgId,
+  };
+}

package/corpus/templates/content/actions/update-document.ts

@@ -40,6 +40,33 @@ export interface DocumentUpdateConflictResponse {
   document: DocumentUpdateResponse;
 }
 
+const documentAuditOwner = Symbol("documentAuditOwner");
+
+type DocumentAuditScopedResult = {
+  [documentAuditOwner]?: string;
+};
+
+function scopeDocumentAudit<T extends object>(result: T, ownerEmail: string) {
+  Object.defineProperty(result, documentAuditOwner, { value: ownerEmail });
+  return result;
+}
+
+function isFavoriteOnlyUpdate(args: {
+  isFavorite?: boolean;
+  title?: string;
+  content?: string;
+  description?: string;
+  icon?: string | null;
+}) {
+  return (
+    args.isFavorite !== undefined &&
+    args.title === undefined &&
+    args.content === undefined &&
+    args.description === undefined &&
+    args.icon === undefined
+  );
+}
+
 function nanoid(size = 12): string {
   const chars =
     "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
@@ -301,6 +328,29 @@ export default defineAction({
       .default([])
       .describe("Exact item versions that influenced this agent update."),
   }),
+  audit: {
+    // Document bodies and personal favorite preferences are both sensitive.
+    // Keep actor/target/outcome attribution without copying mutation payloads
+    // into an owner-visible audit row.
+    recordInputs: false,
+    target: (args, result) => {
+      const favoriteOnly = isFavoriteOnlyUpdate(args);
+      return {
+        type: "document",
+        id: args.id,
+        // Favorites are a private preference owned by the actor, even when
+        // the underlying document belongs to somebody else.
+        ownerEmail: favoriteOnly
+          ? undefined
+          : (result as DocumentAuditScopedResult | null)?.[documentAuditOwner],
+        visibility: "private",
+      };
+    },
+    summary: (args, result) =>
+      (result as DocumentUpdateConflictResponse | null)?.conflict
+        ? `Document update conflicted for ${args.id}`
+        : `Updated document ${args.id}`,
+  },
   run: async (
     args,
     ctx,
@@ -315,12 +365,7 @@ export default defineAction({
     const isAgentCaller =
       ctx?.caller === "tool" || ctx?.caller === "mcp" || ctx?.caller === "a2a";
 
-    const favoriteOnly =
-      args.isFavorite !== undefined &&
-      args.title === undefined &&
-      args.content === undefined &&
-      args.description === undefined &&
-      args.icon === undefined;
+    const favoriteOnly = isFavoriteOnlyUpdate(args);
     const access = favoriteOnly
       ? await resolveContentDocumentAccess(id)
       : await assertAccess("document", id, "editor");
@@ -411,6 +456,11 @@ export default defineAction({
       args.title !== undefined && args.title !== existing.title;
     const contentChanged =
       content !== undefined && content !== existing.content;
+    const clearsNonEmptyContent =
+      contentChanged &&
+      content !== undefined &&
+      isEffectivelyEmptyDocumentContent(content) &&
+      !isEffectivelyEmptyDocumentContent(existing.content);
     const iconChanged = args.icon !== undefined && args.icon !== existing.icon;
     const favoriteChanged =
       args.isFavorite !== undefined && args.isFavorite !== currentFavorite;
@@ -426,40 +476,6 @@ export default defineAction({
       favoriteChanged ||
       descriptionChanged;
 
-    // Snapshot the current state before applying content/title changes.
-    // Versions are scoped to the document owner, not the caller — an editor
-    // share collaborator shouldn't create a phantom version row under their
-    // own email.
-    if (titleChanged || contentChanged) {
-      const [latestVersion] = await db
-        .select({ createdAt: schema.documentVersions.createdAt })
-        .from(schema.documentVersions)
-        .where(
-          and(
-            eq(schema.documentVersions.documentId, id),
-            eq(schema.documentVersions.ownerEmail, ownerEmail),
-          ),
-        )
-        .orderBy(desc(schema.documentVersions.createdAt))
-        .limit(1);
-
-      const shouldSnapshot =
-        !latestVersion ||
-        Date.now() - new Date(latestVersion.createdAt).getTime() >
-          SNAPSHOT_INTERVAL_MS;
-
-      if (shouldSnapshot) {
-        await db.insert(schema.documentVersions).values({
-          id: nanoid(),
-          ownerEmail,
-          documentId: id,
-          title: existing.title,
-          content: existing.content,
-          createdAt: new Date().toISOString(),
-        });
-      }
-    }
-
     let softDeletedDatabaseIds: string[] = [];
     let creativeContext:
       | Awaited<ReturnType<typeof documentMutationCreativeContext>>
@@ -507,6 +523,36 @@ export default defineAction({
             .where(eq(schema.documents.id, id));
         }
 
+        if (titleChanged || contentChanged) {
+          const [latestVersion] = await tx
+            .select({ createdAt: schema.documentVersions.createdAt })
+            .from(schema.documentVersions)
+            .where(
+              and(
+                eq(schema.documentVersions.documentId, id),
+                eq(schema.documentVersions.ownerEmail, ownerEmail),
+              ),
+            )
+            .orderBy(desc(schema.documentVersions.createdAt))
+            .limit(1);
+          const shouldSnapshot =
+            clearsNonEmptyContent ||
+            !latestVersion ||
+            Date.now() - new Date(latestVersion.createdAt).getTime() >
+              SNAPSHOT_INTERVAL_MS;
+
+          if (shouldSnapshot) {
+            await tx.insert(schema.documentVersions).values({
+              id: nanoid(),
+              ownerEmail,
+              documentId: id,
+              title: existing.title,
+              content: existing.content,
+              createdAt: new Date().toISOString(),
+            });
+          }
+        }
+
         if (favoriteChanged) {
           await setFavoriteMembership({
             db: tx,
@@ -580,30 +626,35 @@ export default defineAction({
           .select()
           .from(schema.documents)
           .where(eq(schema.documents.id, id));
-        return {
-          conflict: true,
-          id,
-          document: {
-            id: current.id,
-            urlPath: `/page/${current.id}`,
-            parentId: current.parentId,
-            title: current.title,
-            content: current.content,
-            description: current.description,
-            icon: current.icon,
-            position: current.position,
-            isFavorite: currentFavorite,
-            hideFromSearch: parseDocumentHideFromSearch(current.hideFromSearch),
-            visibility: current.visibility,
-            accessRole: access.role,
-            canEdit: canEditRole(access.role),
-            canManage: canManageRole(access.role),
-            createdAt: current.createdAt,
-            updatedAt: current.updatedAt,
-            source: serializeDocumentSource(current),
-            softDeletedDatabaseIds: [],
-          },
-        };
+        return scopeDocumentAudit(
+          {
+            conflict: true,
+            id,
+            document: {
+              id: current.id,
+              urlPath: `/page/${current.id}`,
+              parentId: current.parentId,
+              title: current.title,
+              content: current.content,
+              description: current.description,
+              icon: current.icon,
+              position: current.position,
+              isFavorite: currentFavorite,
+              hideFromSearch: parseDocumentHideFromSearch(
+                current.hideFromSearch,
+              ),
+              visibility: current.visibility,
+              accessRole: access.role,
+              canEdit: canEditRole(access.role),
+              canManage: canManageRole(access.role),
+              createdAt: current.createdAt,
+              updatedAt: current.updatedAt,
+              source: serializeDocumentSource(current),
+              softDeletedDatabaseIds: [],
+            },
+          } satisfies DocumentUpdateConflictResponse,
+          ownerEmail,
+        );
       }
 
       if (contentChanged) {
@@ -665,32 +716,35 @@ export default defineAction({
 
     await writeAppState("refresh-signal", { ts: Date.now() });
 
-    return {
-      id: doc.id,
-      urlPath: `/page/${doc.id}`,
-      parentId: doc.parentId,
-      title: doc.title,
-      content: doc.content,
-      description: doc.description,
-      icon: doc.icon,
-      position: doc.position,
-      isFavorite: finalFavorite,
-      hideFromSearch: parseDocumentHideFromSearch(doc.hideFromSearch),
-      visibility: doc.visibility,
-      accessRole: access.role,
-      canEdit: canEditRole(access.role),
-      canManage: canManageRole(access.role),
-      createdAt: doc.createdAt,
-      updatedAt: doc.updatedAt,
-      source: serializeDocumentSource(doc),
-      softDeletedDatabaseIds,
-      ...(creativeContext
-        ? {
-            contextMode: creativeContext.contextMode,
-            contextPackId: creativeContext.contextPackId,
-            reuseLabels: creativeContext.reuseLabels,
-          }
-        : {}),
-    };
+    return scopeDocumentAudit(
+      {
+        id: doc.id,
+        urlPath: `/page/${doc.id}`,
+        parentId: doc.parentId,
+        title: doc.title,
+        content: doc.content,
+        description: doc.description,
+        icon: doc.icon,
+        position: doc.position,
+        isFavorite: finalFavorite,
+        hideFromSearch: parseDocumentHideFromSearch(doc.hideFromSearch),
+        visibility: doc.visibility,
+        accessRole: access.role,
+        canEdit: canEditRole(access.role),
+        canManage: canManageRole(access.role),
+        createdAt: doc.createdAt,
+        updatedAt: doc.updatedAt,
+        source: serializeDocumentSource(doc),
+        softDeletedDatabaseIds,
+        ...(creativeContext
+          ? {
+              contextMode: creativeContext.contextMode,
+              contextPackId: creativeContext.contextPackId,
+              reuseLabels: creativeContext.reuseLabels,
+            }
+          : {}),
+      } satisfies DocumentUpdateResponse,
+      ownerEmail,
+    );
   },
 });

package/corpus/templates/content/app/components/editor/CommentComposer.tsx

@@ -28,6 +28,7 @@ interface CommentComposerProps {
   members: MentionMember[];
   placeholder?: string;
   autoFocus?: boolean;
+  disabled?: boolean;
   rows?: number;
   className?: string;
 }
@@ -52,6 +53,7 @@ export const CommentComposer = forwardRef<
     members,
     placeholder,
     autoFocus,
+    disabled = false,
     rows = 2,
     className,
   },
@@ -158,6 +160,7 @@ export const CommentComposer = forwardRef<
       <textarea
         ref={setRefs}
         value={value}
+        disabled={disabled}
         rows={rows}
         onChange={(e) => {
           onChange(e.target.value);
@@ -177,7 +180,7 @@ export const CommentComposer = forwardRef<
           "w-full resize-none bg-transparent text-sm placeholder:text-muted-foreground focus:outline-none"
         }
       />
-      {menuOpen && (
+      {!disabled && menuOpen && (
         <div className="absolute left-0 right-0 top-full z-20 mt-1 overflow-hidden rounded-md border border-border bg-popover py-1 shadow-md">
           {filtered.map((member, i) => (
             <button