@vertesia/ui 1.5.0-dev.20260722.120446Z → 1.5.0-dev.20260725.083715Z

package/src/features/store/objects/components/documentEditingRun.ts

@@ -0,0 +1,184 @@
+import type { AgentsApi } from '@vertesia/client';
+import type { AgentRun } from '@vertesia/common';
+
+const DOCUMENT_EDITING_TAG = 'document-editing';
+const DOCUMENT_ROOT_TAG_PREFIX = 'document-root:';
+const LEGACY_DOCUMENT_TAG_PREFIX = 'document:';
+export const DOCUMENT_EDITING_DEFAULT_INTERACTION = 'sys:GeneralAgent';
+const openDocumentEditingScopes = new Set<string>();
+const MARKDOWN_CONTENT_TYPES = new Set(['text/markdown', 'text/x-markdown']);
+const DOCUMENT_EDITING_CONTENT_TYPES = new Set([...MARKDOWN_CONTENT_TYPES, 'text/plain']);
+
+export type DocumentEditingRunProperties = {
+    resource_kind: 'store_document';
+    document_id: string;
+    document_root_id: string;
+};
+
+export interface DocumentEditingRunIdentity {
+    tags: string[];
+    properties: DocumentEditingRunProperties;
+}
+
+type DocumentEditingRunApi = Pick<AgentsApi, 'list' | 'retrieve' | 'search'>;
+
+export function createDocumentEditingScopeKey(projectId: string, documentRootId: string): string {
+    return `${projectId}:${documentRootId}`;
+}
+
+export function isDocumentEditingScopeOpen(scopeKey: string): boolean {
+    return openDocumentEditingScopes.has(scopeKey);
+}
+
+export function setDocumentEditingScopeOpen(scopeKey: string, isOpen: boolean): void {
+    if (isOpen) {
+        openDocumentEditingScopes.add(scopeKey);
+    } else {
+        openDocumentEditingScopes.delete(scopeKey);
+    }
+}
+
+function getRecord(value: unknown): Record<string, unknown> | undefined {
+    return value && typeof value === 'object' && !Array.isArray(value) ? (value as Record<string, unknown>) : undefined;
+}
+
+function documentRootTag(documentRootId: string): string {
+    return `${DOCUMENT_ROOT_TAG_PREFIX}${documentRootId}`;
+}
+
+function legacyDocumentTag(documentId: string): string {
+    return `${LEGACY_DOCUMENT_TAG_PREFIX}${documentId}`;
+}
+
+export function createDocumentEditingRunIdentity(
+    documentId: string,
+    documentRootId: string,
+): DocumentEditingRunIdentity {
+    return {
+        tags: [DOCUMENT_EDITING_TAG, documentRootTag(documentRootId), legacyDocumentTag(documentId)],
+        properties: {
+            resource_kind: 'store_document',
+            document_id: documentId,
+            document_root_id: documentRootId,
+        },
+    };
+}
+
+export function getDocumentTextActionAccess(canEdit: boolean, canCollaborate: boolean) {
+    return {
+        canEdit,
+        canCollaborate,
+    };
+}
+
+function normalizedContentType(contentType: string | undefined): string | undefined {
+    return contentType?.split(';', 1)[0]?.trim().toLowerCase() || undefined;
+}
+
+export function isMarkdownContentType(contentType: string | undefined): boolean {
+    const normalized = normalizedContentType(contentType);
+    return normalized !== undefined && MARKDOWN_CONTENT_TYPES.has(normalized);
+}
+
+export function isDocumentEditingContentType(contentType: string | undefined): boolean {
+    const normalized = normalizedContentType(contentType);
+    return normalized !== undefined && DOCUMENT_EDITING_CONTENT_TYPES.has(normalized);
+}
+
+export function isDocumentEditingRun(
+    run: AgentRun,
+    documentId: string,
+    documentRootId: string,
+    startedBy: string,
+    interaction = DOCUMENT_EDITING_DEFAULT_INTERACTION,
+): boolean {
+    if (run.interaction !== interaction || run.started_by !== startedBy) return false;
+    // A cancelled run was explicitly terminated by the user; never resume it as the editing session.
+    if (run.status === 'cancelled') return false;
+
+    const tags = run.tags ?? [];
+    if (!tags.includes(DOCUMENT_EDITING_TAG)) return false;
+
+    const properties = getRecord(run.properties);
+    const hasStableRootTag = tags.includes(documentRootTag(documentRootId));
+    if (hasStableRootTag) {
+        return properties?.resource_kind === 'store_document' && properties.document_root_id === documentRootId;
+    }
+
+    // Runs created before stable root properties were added only carry a document tag.
+    return tags.includes(legacyDocumentTag(documentRootId)) || tags.includes(legacyDocumentTag(documentId));
+}
+
+async function retrieveMatchingRun(
+    agents: DocumentEditingRunApi,
+    runIds: string[],
+    documentId: string,
+    documentRootId: string,
+    startedBy: string,
+    interaction: string,
+): Promise<AgentRun | undefined> {
+    for (const runId of runIds) {
+        try {
+            const run = await agents.retrieve(runId);
+            if (isDocumentEditingRun(run, documentId, documentRootId, startedBy, interaction)) return run;
+        } catch {
+            // The run may have been deleted between search and retrieval. Try the next candidate.
+        }
+    }
+    return undefined;
+}
+
+export async function findDocumentEditingRun(
+    agents: DocumentEditingRunApi,
+    documentId: string,
+    documentRootId: string,
+    startedBy: string,
+    interaction = DOCUMENT_EDITING_DEFAULT_INTERACTION,
+): Promise<AgentRun | undefined> {
+    const lookupTags = [
+        documentRootTag(documentRootId),
+        legacyDocumentTag(documentRootId),
+        legacyDocumentTag(documentId),
+    ];
+    const searchedRunIds = new Set<string>();
+
+    for (const tag of new Set(lookupTags)) {
+        try {
+            const response = await agents.search({
+                interaction,
+                started_by: startedBy,
+                tags: [tag],
+                limit: 20,
+                sort: ['updated_at:desc'],
+            });
+            const candidateIds = response.hits.map((hit) => hit.id).filter((id) => !searchedRunIds.has(id));
+            for (const id of candidateIds) {
+                searchedRunIds.add(id);
+            }
+            const run = await retrieveMatchingRun(
+                agents,
+                candidateIds,
+                documentId,
+                documentRootId,
+                startedBy,
+                interaction,
+            );
+            if (run) return run;
+        } catch {
+            // Fall through to the authoritative Mongo-backed list lookup below.
+            break;
+        }
+    }
+
+    const response = await agents.list({
+        interaction,
+        started_by: startedBy,
+        limit: 100,
+        sort: 'updated_at',
+        order: 'desc',
+    });
+    return response.items.find(
+        (run): run is AgentRun =>
+            run.run_kind === 'agent' && isDocumentEditingRun(run, documentId, documentRootId, startedBy, interaction),
+    );
+}

package/src/features/store/objects/components/documentEditingTarget.test.ts

@@ -0,0 +1,96 @@
+import type { ContentObject, ContentObjectItem } from '@vertesia/common';
+import { describe, expect, it, vi } from 'vitest';
+import {
+    type DocumentEditingTargetApi,
+    DocumentEditingTargetError,
+    resolveDocumentEditingTarget,
+} from './documentEditingTarget.js';
+
+function contentObject(id: string, head: boolean, etag = `${id}-etag`): ContentObject {
+    return {
+        id,
+        content: { source: `gs://bucket/${id}.md`, type: 'text/markdown', etag },
+        revision: { root: 'root-id', parent: 'root-id', head },
+    } as unknown as ContentObject;
+}
+
+function revisionItem(id: string, head: boolean): ContentObjectItem {
+    return {
+        id,
+        revision: { root: 'root-id', parent: 'root-id', head },
+    } as unknown as ContentObjectItem;
+}
+
+function targetApi(): DocumentEditingTargetApi & {
+    retrieve: ReturnType<typeof vi.fn<(id: string) => Promise<ContentObject>>>;
+    getRevisions: ReturnType<typeof vi.fn<(id: string) => Promise<ContentObjectItem[]>>>;
+    getObjectText: ReturnType<typeof vi.fn<(id: string) => Promise<{ text?: string }>>>;
+} {
+    return {
+        retrieve: vi.fn<(id: string) => Promise<ContentObject>>(),
+        getRevisions: vi.fn<(id: string) => Promise<ContentObjectItem[]>>(),
+        getObjectText: vi.fn<(id: string) => Promise<{ text?: string }>>(),
+    };
+}
+
+describe('resolveDocumentEditingTarget', () => {
+    it('uses a freshly retrieved head revision and its text', async () => {
+        const objects = targetApi();
+        objects.retrieve.mockResolvedValue(contentObject('head-id', true));
+        objects.getObjectText.mockResolvedValue({ text: '# Current head' });
+
+        await expect(resolveDocumentEditingTarget(objects, 'head-id')).resolves.toEqual({
+            id: 'head-id',
+            etag: 'head-id-etag',
+            content: '# Current head',
+        });
+        expect(objects.getRevisions).not.toHaveBeenCalled();
+    });
+
+    it('resolves a historical revision to the unique current head', async () => {
+        const objects = targetApi();
+        objects.retrieve
+            .mockResolvedValueOnce(contentObject('old-id', false))
+            .mockResolvedValueOnce(contentObject('head-id', true));
+        objects.getRevisions.mockResolvedValue([revisionItem('old-id', false), revisionItem('head-id', true)]);
+        objects.getObjectText.mockResolvedValue({ text: '# Current head' });
+
+        await expect(resolveDocumentEditingTarget(objects, 'old-id')).resolves.toEqual({
+            id: 'head-id',
+            etag: 'head-id-etag',
+            content: '# Current head',
+        });
+        expect(objects.retrieve).toHaveBeenNthCalledWith(2, 'head-id');
+        expect(objects.getObjectText).toHaveBeenCalledWith('head-id');
+    });
+
+    it('rejects a historical revision when the current head cannot be proven', async () => {
+        const objects = targetApi();
+        objects.retrieve.mockResolvedValue(contentObject('old-id', false));
+        objects.getRevisions.mockResolvedValue([revisionItem('old-id', false)]);
+
+        await expect(resolveDocumentEditingTarget(objects, 'old-id')).rejects.toBeInstanceOf(
+            DocumentEditingTargetError,
+        );
+        expect(objects.getObjectText).not.toHaveBeenCalled();
+    });
+
+    it('rejects when the resolved head changes before it can be loaded', async () => {
+        const objects = targetApi();
+        objects.retrieve
+            .mockResolvedValueOnce(contentObject('old-id', false))
+            .mockResolvedValueOnce(contentObject('former-head-id', false));
+        objects.getRevisions.mockResolvedValue([revisionItem('old-id', false), revisionItem('former-head-id', true)]);
+
+        await expect(resolveDocumentEditingTarget(objects, 'old-id')).rejects.toThrow('is no longer the current head');
+        expect(objects.getObjectText).not.toHaveBeenCalled();
+    });
+
+    it('rejects a target without a content ETag', async () => {
+        const objects = targetApi();
+        objects.retrieve.mockResolvedValue(contentObject('head-id', true, ''));
+
+        await expect(resolveDocumentEditingTarget(objects, 'head-id')).rejects.toThrow('has no content ETag');
+        expect(objects.getObjectText).not.toHaveBeenCalled();
+    });
+});

package/src/features/store/objects/components/documentEditingTarget.ts

@@ -0,0 +1,63 @@
+import type { ContentObject, ContentObjectItem, ContentObjectTextResponse } from '@vertesia/common';
+
+export interface DocumentEditingTargetApi {
+    retrieve(id: string): Promise<ContentObject>;
+    getRevisions(id: string): Promise<ContentObjectItem[]>;
+    getObjectText(id: string): Promise<ContentObjectTextResponse>;
+}
+
+export interface ResolvedDocumentEditingTarget {
+    id: string;
+    etag: string;
+    content: string;
+}
+
+export class DocumentEditingTargetError extends Error {
+    constructor(message: string, cause?: unknown) {
+        super(message, cause === undefined ? undefined : { cause });
+        this.name = 'DocumentEditingTargetError';
+    }
+}
+
+/**
+ * Resolve the current head and load its write precondition and text as one unit.
+ * Nothing from a historical revision is returned when the head cannot be proven.
+ */
+export async function resolveDocumentEditingTarget(
+    objects: DocumentEditingTargetApi,
+    requestedDocumentId: string,
+): Promise<ResolvedDocumentEditingTarget> {
+    const requestedObject = await objects.retrieve(requestedDocumentId);
+    let targetObject = requestedObject;
+    const resolvingHistoricalRevision = Boolean(requestedObject.revision && !requestedObject.revision.head);
+
+    if (resolvingHistoricalRevision) {
+        const revisions = await objects.getRevisions(requestedObject.id);
+        const heads = revisions.filter((revision) => revision.revision?.head === true);
+        if (heads.length !== 1) {
+            throw new DocumentEditingTargetError(
+                `Expected one head revision for document ${requestedDocumentId}, found ${heads.length}`,
+            );
+        }
+        targetObject = await objects.retrieve(heads[0].id);
+        if (targetObject.revision?.head !== true) {
+            throw new DocumentEditingTargetError(`Resolved document ${targetObject.id} is no longer the current head`);
+        }
+    }
+
+    const etag = targetObject.content?.etag;
+    if (!etag) {
+        throw new DocumentEditingTargetError(`Document ${targetObject.id} has no content ETag`);
+    }
+
+    const response = await objects.getObjectText(targetObject.id);
+    if (typeof response.text !== 'string') {
+        throw new DocumentEditingTargetError(`Document ${targetObject.id} has no text content`);
+    }
+
+    return {
+        id: targetObject.id,
+        etag,
+        content: response.text,
+    };
+}

package/src/features/store/objects/components/index.ts

@@ -1,5 +1,6 @@
 export * from './ContentDispositionButton';
 export * from './ContentOverview';
+export * from './DocumentEditingPanel';
 export * from './DocumentIcon';
 export * from './DocumentInput';
 export * from './PropertiesEditorModal';

package/src/features/store/objects/components/useContentPanelHooks.ts

@@ -1,7 +1,7 @@
 import { type DocAnalyzerProgress, MarkdownRenditionFormat, WorkflowExecutionStatus } from '@vertesia/common';
 import { i18nInstance, NAMESPACE } from '@vertesia/ui/i18n';
 import { useUserSession } from '@vertesia/ui/session';
-import { useCallback, useEffect, useState } from 'react';
+import { useCallback, useEffect, useLayoutEffect, useRef, useState } from 'react';
 
 // Maximum text size before cropping (128K characters)
 const MAX_TEXT_DISPLAY_SIZE = 128 * 1024;
@@ -9,7 +9,7 @@ const MAX_TEXT_DISPLAY_SIZE = 128 * 1024;
 /**
  * Hook for managing object text loading and cropping.
  */
-export function useObjectText(objectId: string, initialText?: string, loadOnMount = false) {
+export function useObjectText(objectId: string, initialText?: string, loadOnMount = false, changeGroupId = objectId) {
     const { store } = useUserSession();
 
     const [fullText, setFullText] = useState<string | undefined>(initialText);
@@ -21,56 +21,81 @@ export function useObjectText(objectId: string, initialText?: string, loadOnMoun
     });
     const [isLoading, setIsLoading] = useState(false);
     const [isCropped, setIsCropped] = useState(() => !!initialText && initialText.length > MAX_TEXT_DISPLAY_SIZE);
+    const [changeHighlight, setChangeHighlight] = useState<{ previousText: string; version: number }>();
+    const fullTextRef = useRef(initialText);
+    const objectIdRef = useRef(objectId);
+    const changeGroupIdRef = useRef(changeGroupId);
+    const suppressNextHighlightRef = useRef(false);
+
+    const applyText = useCallback((nextText: string | undefined, shouldHighlight = true) => {
+        const previousText = fullTextRef.current;
+        if (shouldHighlight && previousText && nextText && previousText !== nextText) {
+            setChangeHighlight((current) => ({
+                previousText,
+                version: (current?.version ?? 0) + 1,
+            }));
+        } else if (!shouldHighlight) {
+            setChangeHighlight(undefined);
+        }
+
+        fullTextRef.current = nextText;
+        setFullText(nextText);
+        if (nextText && nextText.length > MAX_TEXT_DISPLAY_SIZE) {
+            setDisplayText(nextText.substring(0, MAX_TEXT_DISPLAY_SIZE));
+            setIsCropped(true);
+        } else {
+            setDisplayText(nextText);
+            setIsCropped(false);
+        }
+    }, []);
 
     const loadText = useCallback(() => {
+        const requestedObjectId = objectId;
+        const requestedChangeGroupId = changeGroupId;
         setIsLoading(true);
         store.objects
             .getObjectText(objectId)
             .then((res) => {
-                setFullText(res.text);
-                if (res.text && res.text.length > MAX_TEXT_DISPLAY_SIZE) {
-                    setDisplayText(res.text.substring(0, MAX_TEXT_DISPLAY_SIZE));
-                    setIsCropped(true);
-                } else {
-                    setDisplayText(res.text);
-                    setIsCropped(false);
-                }
+                if (objectIdRef.current !== requestedObjectId) return;
+                const shouldHighlight =
+                    changeGroupIdRef.current === requestedChangeGroupId && !suppressNextHighlightRef.current;
+                applyText(res.text, shouldHighlight);
+                suppressNextHighlightRef.current = false;
             })
             .catch((err) => {
                 console.error('Failed to load text', err);
-                setFullText(undefined);
-                setDisplayText(undefined);
-                setIsCropped(false);
             })
             .finally(() => {
-                setIsLoading(false);
+                if (objectIdRef.current === requestedObjectId) setIsLoading(false);
             });
-    }, [objectId, store]);
+    }, [applyText, changeGroupId, objectId, store]);
 
     // Reset state when objectId changes
-    useEffect(() => {
-        // Reset to initial text for new object
-        if (initialText && initialText.length > MAX_TEXT_DISPLAY_SIZE) {
-            setFullText(initialText);
-            setDisplayText(initialText.substring(0, MAX_TEXT_DISPLAY_SIZE));
-            setIsCropped(true);
-        } else {
-            setFullText(initialText);
-            setDisplayText(initialText);
-            setIsCropped(false);
+    useLayoutEffect(() => {
+        const objectChanged = objectIdRef.current !== objectId;
+        const changeGroupChanged = changeGroupIdRef.current !== changeGroupId;
+        objectIdRef.current = objectId;
+        changeGroupIdRef.current = changeGroupId;
+        if (changeGroupChanged) suppressNextHighlightRef.current = true;
+
+        // Keep the previous revision mounted until the next revision's text is ready.
+        if (initialText !== undefined) {
+            applyText(initialText, !changeGroupChanged);
+            suppressNextHighlightRef.current = false;
         }
 
         // Load text if requested
-        if (loadOnMount && !initialText) {
+        if (loadOnMount && initialText === undefined && (objectChanged || fullTextRef.current === undefined)) {
             loadText();
         }
-    }, [initialText, loadOnMount, loadText]);
+    }, [applyText, changeGroupId, initialText, loadOnMount, loadText, objectId]);
 
     return {
         fullText,
         displayText,
         isLoading,
         isCropped,
+        changeHighlight,
         loadText,
     };
 }

package/src/features/store/objects/components/useDownloadFile.test.ts

@@ -0,0 +1,20 @@
+import type { ContentObject } from '@vertesia/common';
+import { describe, expect, it } from 'vitest';
+import { getContentObjectDownloadName } from './useDownloadFile.js';
+
+describe('getContentObjectDownloadName', () => {
+    it('preserves the original source extension instead of an extensionless display name', () => {
+        const object = {
+            name: 'Quarterly Report',
+            content: { name: 'quarterly-report.md', type: 'text/markdown' },
+        } as ContentObject;
+
+        expect(getContentObjectDownloadName(object)).toBe('quarterly-report.md');
+    });
+
+    it('falls back to the object name when the content has no source name', () => {
+        const object = { name: 'Quarterly Report' } as ContentObject;
+
+        expect(getContentObjectDownloadName(object)).toBe('Quarterly Report');
+    });
+});

package/src/features/store/objects/components/useDownloadFile.ts

@@ -1,5 +1,5 @@
 import type { VertesiaClient, ZenoClient } from '@vertesia/client';
-import type { MarkdownRenditionFormat, RenderMarkdownPayload } from '@vertesia/common';
+import type { ContentObject, MarkdownRenditionFormat, RenderMarkdownPayload } from '@vertesia/common';
 import type { ToastFn } from '@vertesia/ui/core';
 import { i18nInstance, NAMESPACE } from '@vertesia/ui/i18n';
 import { useCallback, useState } from 'react';
@@ -37,6 +37,10 @@ export interface UseDownloadFileResult {
     isDownloading: boolean;
 }
 
+export function getContentObjectDownloadName(object: Pick<ContentObject, 'name' | 'content'>): string | undefined {
+    return object.content?.name || object.name;
+}
+
 /**
  * Hook for downloading files from various sources.
  * Handles GCS URIs (via client.files API), direct URLs, and markdown rendering.

package/src/features/store/objects/selection/actions/StartWorkflowButton.tsx

@@ -71,7 +71,7 @@ function StartWorkflowModal({ objectIds, onClose }: StartWorkflowModalProps) {
     };
 
     return (
-        <Modal isOpen onClose={onClose}>
+        <Modal isOpen onClose={onClose} size="lg">
             <ModalTitle>{t('store.actions.startWorkflowByRule')}</ModalTitle>
             <ModalBody>
                 <div className="pb-2">{t('store.actions.chooseWorkflowRule')}</div>
@@ -82,7 +82,7 @@ function StartWorkflowModal({ objectIds, onClose }: StartWorkflowModalProps) {
                 ) : (
                     <div className="max-h-[420px] overflow-y-auto border-border border rounded-md">
                         <SelectList
-                            className="text-start"
+                            className="text-start w-full"
                             options={rules ?? []}
                             value={selected}
                             onChange={setSelected}