@agent-native/core 0.85.7 → 0.86.0

package/corpus/templates/content/actions/list-documents.ts

@@ -98,22 +98,21 @@ export default defineAction({
 
     const shareRoleByDocumentId = new Map<string, ShareRole>();
     const notionPageIdByDocumentId = new Map<string, string>();
-    if (documents.length > 0) {
-      const notionLinks = await db
-        .select({
-          documentId: schema.documentSyncLinks.documentId,
-          remotePageId: schema.documentSyncLinks.remotePageId,
-        })
-        .from(schema.documentSyncLinks)
-        .where(
-          inArray(
-            schema.documentSyncLinks.documentId,
-            documents.map((d) => d.id),
-          ),
-        );
-      for (const link of notionLinks) {
-        notionPageIdByDocumentId.set(link.documentId, link.remotePageId);
+    const databaseByDocumentId = new Map<
+      string,
+      typeof schema.contentDatabases.$inferSelect
+    >();
+    const databaseMembershipByDocumentId = new Map<
+      string,
+      {
+        item: typeof schema.contentDatabaseItems.$inferSelect;
+        database: typeof schema.contentDatabases.$inferSelect;
       }
+    >();
+    const softDeletedDocumentIds = new Set<string>();
+
+    if (documents.length > 0) {
+      const visibleDocumentIds = documents.map((d) => d.id);
 
       const principalClauses: NonNullable<ReturnType<typeof and>>[] = [];
       if (userEmail) {
@@ -133,97 +132,105 @@ export default defineAction({
         );
       }
 
-      if (principalClauses.length > 0) {
-        const shareRows = await db
+      // These queries all depend only on the initial `documents` id list
+      // (already fetched above), not on each other's results, so they run
+      // concurrently instead of as sequential round-trips.
+      const [
+        notionLinks,
+        shareRows,
+        databases,
+        databaseMemberships,
+        softDeletedDatabases,
+      ] = await Promise.all([
+        db
+          .select({
+            documentId: schema.documentSyncLinks.documentId,
+            remotePageId: schema.documentSyncLinks.remotePageId,
+          })
+          .from(schema.documentSyncLinks)
+          .where(
+            inArray(schema.documentSyncLinks.documentId, visibleDocumentIds),
+          ),
+        principalClauses.length > 0
+          ? db
+              .select({
+                resourceId: schema.documentShares.resourceId,
+                role: schema.documentShares.role,
+              })
+              .from(schema.documentShares)
+              .where(
+                and(
+                  inArray(schema.documentShares.resourceId, visibleDocumentIds),
+                  or(...principalClauses),
+                ),
+              )
+          : Promise.resolve([] as { resourceId: string; role: ShareRole }[]),
+        db
+          .select()
+          .from(schema.contentDatabases)
+          .where(
+            and(
+              inArray(schema.contentDatabases.documentId, visibleDocumentIds),
+              isNull(schema.contentDatabases.deletedAt),
+            ),
+          ),
+        db
           .select({
-            resourceId: schema.documentShares.resourceId,
-            role: schema.documentShares.role,
+            item: schema.contentDatabaseItems,
+            database: schema.contentDatabases,
           })
-          .from(schema.documentShares)
+          .from(schema.contentDatabaseItems)
+          .innerJoin(
+            schema.contentDatabases,
+            eq(
+              schema.contentDatabases.id,
+              schema.contentDatabaseItems.databaseId,
+            ),
+          )
           .where(
             and(
               inArray(
-                schema.documentShares.resourceId,
-                documents.map((d) => d.id),
+                schema.contentDatabaseItems.documentId,
+                visibleDocumentIds,
               ),
-              or(...principalClauses),
+              isNull(schema.contentDatabases.deletedAt),
             ),
-          );
-
-        for (const row of shareRows) {
-          shareRoleByDocumentId.set(
-            row.resourceId,
-            strongerRole(
-              shareRoleByDocumentId.get(row.resourceId) ?? null,
-              row.role,
+          ),
+        db
+          .select({
+            id: schema.contentDatabases.id,
+            documentId: schema.contentDatabases.documentId,
+          })
+          .from(schema.contentDatabases)
+          .where(
+            and(
+              inArray(schema.contentDatabases.documentId, visibleDocumentIds),
+              isNotNull(schema.contentDatabases.deletedAt),
             ),
-          );
-        }
-      }
-    }
+          ),
+      ]);
 
-    const databases =
-      documents.length > 0
-        ? await db
-            .select()
-            .from(schema.contentDatabases)
-            .where(
-              and(
-                inArray(
-                  schema.contentDatabases.documentId,
-                  documents.map((d) => d.id),
-                ),
-                isNull(schema.contentDatabases.deletedAt),
-              ),
-            )
-        : [];
-    const databaseByDocumentId = new Map(
-      databases.map((database) => [database.documentId, database]),
-    );
-    const databaseMemberships =
-      documents.length > 0
-        ? await db
-            .select({
-              item: schema.contentDatabaseItems,
-              database: schema.contentDatabases,
-            })
-            .from(schema.contentDatabaseItems)
-            .innerJoin(
-              schema.contentDatabases,
-              eq(
-                schema.contentDatabases.id,
-                schema.contentDatabaseItems.databaseId,
-              ),
-            )
-            .where(
-              and(
-                inArray(
-                  schema.contentDatabaseItems.documentId,
-                  documents.map((d) => d.id),
-                ),
-                isNull(schema.contentDatabases.deletedAt),
-              ),
-            )
-        : [];
-    const databaseMembershipByDocumentId = new Map(
-      databaseMemberships.map((row) => [row.item.documentId, row]),
-    );
+      for (const link of notionLinks) {
+        notionPageIdByDocumentId.set(link.documentId, link.remotePageId);
+      }
 
-    const softDeletedDocumentIds = new Set<string>();
-    if (documents.length > 0) {
-      const visibleDocumentIds = documents.map((d) => d.id);
-      const softDeletedDatabases = await db
-        .select({
-          id: schema.contentDatabases.id,
-          documentId: schema.contentDatabases.documentId,
-        })
-        .from(schema.contentDatabases)
-        .where(
-          and(
-            inArray(schema.contentDatabases.documentId, visibleDocumentIds),
-            isNotNull(schema.contentDatabases.deletedAt),
+      for (const row of shareRows) {
+        shareRoleByDocumentId.set(
+          row.resourceId,
+          strongerRole(
+            shareRoleByDocumentId.get(row.resourceId) ?? null,
+            row.role,
           ),
         );
+      }
+
+      for (const database of databases) {
+        databaseByDocumentId.set(database.documentId, database);
+      }
+
+      for (const row of databaseMemberships) {
+        databaseMembershipByDocumentId.set(row.item.documentId, row);
+      }
 
       for (const database of softDeletedDatabases) {
         softDeletedDocumentIds.add(database.documentId);

package/corpus/templates/content/actions/search-documents.ts

@@ -17,6 +17,12 @@ function escapeLike(s: string): string {
   return s.replace(/([\\%_])/g, "\\$1");
 }
 
+// `content` here may be a bounded preview (see the `contentPreview`
+// projection below) rather than the full document body. If the query match
+// falls outside the preview window (a deeper match in the full doc, which the
+// SQL LIKE filter already confirmed exists), `indexOf` simply misses and we
+// fall back to a beginning-of-document snippet — the same behavior as the
+// no-match case. The row is still returned either way.
 function makeSnippet(content: string, query: string, radius = 120) {
   const compact = content.replace(/\s+/g, " ").trim();
   if (!compact) return "";
@@ -75,13 +81,23 @@ export default defineAction({
     const db = getDb();
     const pattern = `%${escapeLike(query)}%`;
 
+    // Project a bounded preview of `content` instead of the full column:
+    // document bodies can be multi-MB, and this action only returns a short
+    // snippet (use get-document for full content). 5000 chars is generous
+    // headroom for `makeSnippet`'s 120-char radius even when the match is
+    // deep-ish into the doc, while the true length still comes from SQL
+    // `length()` rather than reading `.length` off a truncated string.
+    // Mirrors the `substr`/`length` projection style in list-documents.ts.
+    // Both `substr` and `length` work identically on SQLite/libsql and
+    // Postgres.
     const docs = await db
       .select({
         id: schema.documents.id,
         parentId: schema.documents.parentId,
         title: schema.documents.title,
         icon: schema.documents.icon,
-        content: schema.documents.content,
+        contentPreview: sql<string>`substr(${schema.documents.content}, 1, 5000)`,
+        contentLength: sql<number>`length(${schema.documents.content})`,
         hideFromSearch: schema.documents.hideFromSearch,
         updatedAt: schema.documents.updatedAt,
       })
@@ -102,8 +118,8 @@ export default defineAction({
         parentId: doc.parentId,
         title: doc.title,
         icon: doc.icon,
-        snippet: makeSnippet(doc.content, query),
-        contentLength: doc.content.length,
+        snippet: makeSnippet(doc.contentPreview, query),
+        contentLength: Number(doc.contentLength) || 0,
         hideFromSearch: parseDocumentHideFromSearch(doc.hideFromSearch),
         updatedAt: doc.updatedAt,
       })),

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

@@ -1,5 +1,6 @@
 import { defineAction } from "@agent-native/core";
 import { writeAppState } from "@agent-native/core/application-state";
+import { agentTouchDocument } from "@agent-native/core/collab";
 import { assertAccess } from "@agent-native/core/sharing";
 import { and, eq, desc } from "drizzle-orm";
 import { z } from "zod";
@@ -63,6 +64,27 @@ function normalizedBuilderBodyProse(content: string | null | undefined) {
     .trim();
 }
 
+/**
+ * Best-effort quote of the first changed span between two document bodies, used
+ * as the `{ kind: "text", quote }` descriptor so the recent-edit highlight lands
+ * on (or near) the region the agent actually rewrote rather than the doc top.
+ * Returns a short slice of the new content around the first divergence.
+ */
+export function firstChangedQuote(
+  previous: string,
+  next: string,
+  maxLen = 80,
+): string {
+  if (!next) return "";
+  if (previous === next) return next.slice(0, maxLen);
+  let start = 0;
+  const min = Math.min(previous.length, next.length);
+  while (start < min && previous[start] === next[start]) start++;
+  // Skip leading whitespace so the quote begins on visible text.
+  while (start < next.length && /\s/.test(next[start])) start++;
+  return next.slice(start, start + maxLen).trim() || next.slice(0, maxLen);
+}
+
 export function isStaleBuilderImageSourceComponentSave(args: {
   incomingContent: string;
   currentContent: string;
@@ -101,10 +123,17 @@ export default defineAction({
       .optional()
       .describe("Favorite status (true/false)"),
   }),
-  run: async (args): Promise<DocumentUpdateResponse> => {
+  run: async (args, ctx): Promise<DocumentUpdateResponse> => {
     const id = args.id;
     if (!id) throw new Error("--id is required");
 
+    // Only surface AI presence for genuine agent invocations (in-app tool loop,
+    // sub-agents/A2A → "tool"; external MCP agents → "mcp"). The browser editor
+    // autosaves through this same action as "frontend"; those must NOT light the
+    // agent flag.
+    const isAgentCaller =
+      ctx?.caller === "tool" || ctx?.caller === "mcp" || ctx?.caller === "a2a";
+
     if ((await isContentLocalFileMode()) && isLocalDocumentId(id)) {
       const doc = await updateLocalFileDocument(id, args);
       await writeAppState("refresh-signal", { ts: Date.now() });
@@ -252,6 +281,30 @@ export default defineAction({
           content ?? "",
         );
       }
+
+      // Make an agent full-content rewrite visible as a live collaborator. This
+      // path replaces the whole body (not a find/replace), so it can't route
+      // through `searchAndReplace`; it keeps the SQL + reconcile delivery and
+      // publishes agent presence + a lingering recent-edit highlight near the
+      // first changed span. Best-effort — never fail the save on presence.
+      if (isAgentCaller && contentChanged) {
+        try {
+          agentTouchDocument(id, {
+            edit: {
+              descriptor: {
+                kind: "text",
+                quote: firstChangedQuote(existing.content ?? "", content ?? ""),
+              },
+              label: (args.title ?? existing.title) || undefined,
+            },
+          });
+        } catch (error) {
+          console.error(
+            "update-document: agent presence publish failed",
+            error,
+          );
+        }
+      }
     }
 
     const [doc] = await db

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

@@ -4,6 +4,7 @@ import {
   generateTabId,
   emailToColor,
   emailToName,
+  useAvatarUrl,
   useSession,
   useT,
   agentNativePath,
@@ -464,16 +465,27 @@ function DocumentEditorBody({ documentId, document }: DocumentEditorBodyProps) {
 
   // Current user info for cursor labels
   const { session } = useSession();
+  const currentUserAvatarUrl = useAvatarUrl(session?.email);
   const currentUser: CollabUser | undefined = session?.email
     ? {
         name: emailToName(session.email),
         email: session.email,
         color: emailToColor(session.email),
+        avatarUrl: currentUserAvatarUrl ?? undefined,
       }
     : undefined;
 
-  // Collaborative editing is write-only for now. Viewers get the SQL snapshot
-  // and skip collab endpoints that reject non-editor access.
+  // Live collaboration for everyone who can open the doc — editors and viewers
+  // alike. Viewers join the shared Y.Doc read-only: they see live keystrokes,
+  // cursors, and presence (Google-Docs style) instead of a lagging SQL snapshot.
+  // The server enforces the split — collab READ routes (state / awareness GET /
+  // users) require viewer access, WRITE routes (update) require editor — so a
+  // viewer's client can subscribe but never push. The editor stays non-editable
+  // for viewers (see `editable={canEdit}` below), and VisualEditor additionally
+  // neutralizes every local Y.Doc mutation for viewers (no seed, no reconcile
+  // apply) so a read-only client can never originate a rejected `/update` POST.
+  // Local-file documents are still excluded (they have no SQL-backed collab doc).
+  const collabEnabled = !isLocalFileDocument;
   const {
     ydoc,
     awareness,
@@ -482,7 +494,7 @@ function DocumentEditorBody({ documentId, document }: DocumentEditorBodyProps) {
     agentActive,
     agentPresent,
   } = useCollaborativeDoc({
-    docId: canEdit && !isLocalFileDocument ? documentId : "",
+    docId: collabEnabled ? documentId : "",
     requestSource: TAB_ID,
     user: currentUser,
   });
@@ -864,6 +876,112 @@ function DocumentEditorBody({ documentId, document }: DocumentEditorBodyProps) {
     flushPendingDocumentSave(pending);
   }, [canEdit, documentId, flushPendingDocumentSave]);
 
+  // Last-chance flush when the tab is being hidden or torn down. A normal
+  // debounced save is an async React-Query mutation; if the page unloads before
+  // it resolves the edit is lost. On `pagehide` / `visibilitychange → hidden` we
+  // fire a `keepalive` POST straight to the update-document action so the write
+  // survives navigation/close. Local-file documents persist to disk, not this
+  // endpoint, so they fall back to the best-effort async flush.
+  useEffect(() => {
+    if (!canEdit) return;
+
+    const flushForTeardown = () => {
+      const pending = pendingDocumentSaveRef.current;
+      if (!pending || !pending.canEditWhenQueued) return;
+
+      // Local-file docs can't be flushed via keepalive fetch; best-effort only.
+      if (isLocalFileDocument || isLinkedLocalSourceDocument) {
+        flushPendingDocumentSave(pending);
+        return;
+      }
+
+      // Mirror saveDocumentImmediately's per-field stale guard + diff so we only
+      // send genuinely-changed, non-stale fields.
+      const serverUpdatedAt = documentUpdatedAtRef.current;
+      const titleIsStale =
+        !!serverUpdatedAt &&
+        !!lastSavedTitleRef.current.updatedAt &&
+        serverUpdatedAt > lastSavedTitleRef.current.updatedAt;
+      const contentIsStale =
+        !!serverUpdatedAt &&
+        !!lastSavedContentRef.current.updatedAt &&
+        serverUpdatedAt > lastSavedContentRef.current.updatedAt;
+
+      const updates: Record<string, string> = {};
+      if (pending.title !== lastSavedTitleRef.current.title && !titleIsStale) {
+        updates.title = pending.title;
+      }
+      if (
+        pending.content !== lastSavedContentRef.current.content &&
+        !contentIsStale
+      ) {
+        updates.content = pending.content;
+      }
+      if (Object.keys(updates).length === 0) return;
+
+      clearTimeout(pending.timeout);
+      saveTimeoutRef.current = null;
+      pendingDocumentSaveRef.current = null;
+
+      try {
+        const url = agentNativePath("/_agent-native/actions/update-document");
+        const body = JSON.stringify({ id: documentId, ...updates });
+        const ok = fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            // Tag as a browser-originated call (ctx.caller = "frontend") so this
+            // never lights the AI-editing flag.
+            "X-Agent-Native-Frontend": "1",
+          },
+          body,
+          keepalive: true,
+          cache: "no-store",
+        });
+        // Adopt an optimistic watermark so a re-render doesn't re-queue the same
+        // save; the server bumps updatedAt, and the next poll reconciles it.
+        const optimisticAt = new Date().toISOString();
+        if (updates.title !== undefined) {
+          lastSavedTitleRef.current = {
+            title: pending.title,
+            updatedAt: optimisticAt,
+          };
+        }
+        if (updates.content !== undefined) {
+          lastSavedContentRef.current = {
+            content: pending.content,
+            updatedAt: optimisticAt,
+          };
+        }
+        void Promise.resolve(ok).catch(() => {
+          /* Page is going away; nothing more we can do. */
+        });
+      } catch {
+        // Fall back to the async flush if the keepalive fetch couldn't start.
+        flushPendingDocumentSave(pending);
+      }
+    };
+
+    const onVisibilityChange = () => {
+      if (window.document.visibilityState === "hidden") flushForTeardown();
+    };
+    window.addEventListener("pagehide", flushForTeardown);
+    window.document.addEventListener("visibilitychange", onVisibilityChange);
+    return () => {
+      window.removeEventListener("pagehide", flushForTeardown);
+      window.document.removeEventListener(
+        "visibilitychange",
+        onVisibilityChange,
+      );
+    };
+  }, [
+    canEdit,
+    documentId,
+    isLocalFileDocument,
+    isLinkedLocalSourceDocument,
+    flushPendingDocumentSave,
+  ]);
+
   // Collab-aware ingest flush: the `pull-document` action writes a one-shot
   // `flush-request-<id>` app-state key when an external agent wants to ingest
   // the document while a live collab session is open. The DB column can lag
@@ -1299,10 +1417,12 @@ function DocumentEditorBody({ documentId, document }: DocumentEditorBodyProps) {
                         }
                         onChange={handleContentChange}
                         onSaveContent={handleContentSaveNow}
-                        ydoc={canEdit && !isLocalFileDocument ? ydoc : null}
-                        awareness={
-                          canEdit && !isLocalFileDocument ? awareness : null
-                        }
+                        // Bind the shared Y.Doc/awareness for viewers too — the
+                        // editor is non-editable for them and VisualEditor blocks
+                        // any local Y.Doc mutation, so they get live edits +
+                        // cursors without ever writing. Excludes local-file docs.
+                        ydoc={collabEnabled ? ydoc : null}
+                        awareness={collabEnabled ? awareness : null}
                         user={currentUser}
                         editable={canEdit}
                         localFileMode={isLocalFileDocument}