@alpaca-editor/core 1.0.4174 → 1.0.4177

package/src/editor/ai/ContextInfoBar.tsx

@@ -42,7 +42,7 @@ export function ContextInfoBar({
 
   const removeContextKey = useCallback(
     async (
-      key: "items" | "componentIds" | "components" | "field" | "comment",
+      key: "items" | "components" | "field" | "comment",
       index?: number,
     ) => {
       if (!agent?.id) return;
@@ -54,7 +54,7 @@ export function ContextInfoBar({
         next.items.splice(index, 1);
         if (next.items.length === 0) delete next.items;
       } else if (
-        (key === "componentIds" || key === "components") &&
+        key === "components" &&
         typeof index === "number" &&
         next.components
       ) {
@@ -137,7 +137,7 @@ export function ContextInfoBar({
     const current = agentMetadata || {};
     const currentComponents = current.components || [];
 
-    const existingIds = new Set(currentComponents.map(c => c.componentId));
+    const existingIds = new Set(currentComponents.map((c) => c.componentId));
     const newComponentIds = editContext.selection.filter(
       (id) => !existingIds.has(id),
     );
@@ -145,16 +145,18 @@ export function ContextInfoBar({
     if (newComponentIds.length === 0) return;
 
     // Get page item descriptor from edit context
-    const pageItem = editContext.currentItemDescriptor ? {
-      id: editContext.currentItemDescriptor.id,
-      language: editContext.currentItemDescriptor.language,
-      version: editContext.currentItemDescriptor.version,
-      name: editContext.contentEditorItem?.name,
-      path: undefined,
-    } : undefined;
+    const pageItem = editContext.currentItemDescriptor
+      ? {
+          id: editContext.currentItemDescriptor.id,
+          language: editContext.currentItemDescriptor.language,
+          version: editContext.currentItemDescriptor.version,
+          name: editContext.contentEditorItem?.name,
+          path: undefined,
+        }
+      : undefined;
 
     // Build new components with page info
-    const newComponents = newComponentIds.map(componentId => ({
+    const newComponents = newComponentIds.map((componentId) => ({
       componentId,
       pageItem: pageItem!,
     }));
@@ -185,21 +187,23 @@ export function ContextInfoBar({
     const current = agentMetadata || {};
     const currentComponents = current.components || [];
 
-    const existingIds = new Set(currentComponents.map(c => c.componentId));
+    const existingIds = new Set(currentComponents.map((c) => c.componentId));
     const newComponentIds = ids.filter((id) => !!id && !existingIds.has(id));
     if (newComponentIds.length === 0) return;
 
     // Get page item descriptor from edit context
-    const pageItem = editContext?.currentItemDescriptor ? {
-      id: editContext.currentItemDescriptor.id,
-      language: editContext.currentItemDescriptor.language,
-      version: editContext.currentItemDescriptor.version,
-      name: editContext.contentEditorItem?.name,
-      path: undefined,
-    } : undefined;
+    const pageItem = editContext?.currentItemDescriptor
+      ? {
+          id: editContext.currentItemDescriptor.id,
+          language: editContext.currentItemDescriptor.language,
+          version: editContext.currentItemDescriptor.version,
+          name: editContext.contentEditorItem?.name,
+          path: undefined,
+        }
+      : undefined;
 
     // Build new components with page info
-    const newComponents = newComponentIds.map(componentId => ({
+    const newComponents = newComponentIds.map((componentId) => ({
       componentId,
       pageItem: pageItem!,
     }));
@@ -351,7 +355,7 @@ export function ContextInfoBar({
   const ctx = agentMetadata;
 
   const hasContext =
-    ctx && (ctx.items?.length || ctx.components?.length || ctx.componentIds?.length || ctx.field);
+    ctx && (ctx.items?.length || ctx.components?.length || ctx.field);
 
   const currentPageAlreadyAdded =
     editContext?.currentItemDescriptor &&
@@ -365,8 +369,7 @@ export function ContextInfoBar({
   const selectedComponentsAlreadyAdded =
     !!editContext?.selection?.length &&
     !!editContext.selection?.every((selectedId) =>
-      ctx?.components?.some(c => c.componentId === selectedId) || 
-      ctx?.componentIds?.includes(selectedId),
+      ctx?.components?.some((c) => c.componentId === selectedId),
     );
 
   const canAddPage =
@@ -404,10 +407,7 @@ export function ContextInfoBar({
 
   if (ctx?.items && ctx.items.length > 0) {
     ctx.items.forEach((page, index) => {
-      const pageLabelName =
-        page.name ||
-        resolvedPageName ||
-        undefined;
+      const pageLabelName = page.name || resolvedPageName || undefined;
       const pageLabel = `${pageLabelName || page.path || page.id} (${page.language}/${page.version})`;
       chips.push(
         <Chip
@@ -432,12 +432,12 @@ export function ContextInfoBar({
           compLabel = (comp?.name as string) || componentId;
         } catch {}
       }
-      
+
       // Include page info in the label
-      const pageInfo = component.pageItem 
+      const pageInfo = component.pageItem
         ? ` on ${component.pageItem.name || component.pageItem.path || component.pageItem.id}`
-        : '';
-      
+        : "";
+
       chips.push(
         <Chip
           key={`component-${index}`}
@@ -447,34 +447,10 @@ export function ContextInfoBar({
         />,
       );
     });
-  } else if (ctx?.componentIds && ctx.componentIds.length > 0) {
-    // Legacy support for componentIds without page info
-    ctx.componentIds.forEach((componentId, index) => {
-      let compLabel: string = componentId as string;
-      if (index === 0 && resolvedComponentName) {
-        compLabel = resolvedComponentName as string;
-      } else if (editContext?.page) {
-        try {
-          const comp = getComponentById(
-            componentId as string,
-            editContext.page,
-          );
-          compLabel = (comp?.name as string) || (componentId as string);
-        } catch {}
-      }
-      chips.push(
-        <Chip
-          key={`component-${index}`}
-          icon={<Puzzle className="h-3 w-3 text-gray-500" strokeWidth={1} />}
-          label={`Component: ${compLabel}`}
-          onRemove={() => removeContextKey("componentIds", index)}
-        />,
-      );
-    });
   }
 
   if (ctx?.field) {
-    const fieldLabel = `${ctx.field.name || resolvedFieldName || ctx.field.fieldId}`;
+    const fieldLabel = `${ctx.field.fieldName || resolvedFieldName || ctx.field.fieldId}`;
     chips.push(
       <Chip
         key="field"
@@ -489,10 +465,7 @@ export function ContextInfoBar({
   const summaryParts: string[] = [];
   if (ctx?.items && ctx.items.length > 0) {
     const first = ctx.items[0]!;
-    const pageLabelName =
-      first.name ||
-      resolvedPageName ||
-      undefined;
+    const pageLabelName = first.name || resolvedPageName || undefined;
     const pageText = pageLabelName || first.path || first.id;
     const more = ctx.items.length > 1 ? ` (+${ctx.items.length - 1})` : "";
     summaryParts.push(`Item: ${pageText}${more}`);
@@ -511,24 +484,10 @@ export function ContextInfoBar({
     const more =
       ctx.components.length > 1 ? ` (+${ctx.components.length - 1})` : "";
     summaryParts.push(`Component: ${compLabel}${more}`);
-  } else if (ctx?.componentIds && ctx.componentIds.length > 0) {
-    // Legacy support for componentIds
-    const firstId = ctx.componentIds[0]!;
-    let compLabel: string = firstId as string;
-    if (resolvedComponentName) compLabel = resolvedComponentName as string;
-    else if (editContext?.page) {
-      try {
-        const comp = getComponentById(firstId as string, editContext.page);
-        compLabel = (comp?.name as string) || (firstId as string);
-      } catch {}
-    }
-    const more =
-      ctx.componentIds.length > 1 ? ` (+${ctx.componentIds.length - 1})` : "";
-    summaryParts.push(`Component: ${compLabel}${more}`);
   }
   if (ctx?.field) {
     summaryParts.push(
-      `Field: ${ctx.field.name || resolvedFieldName || ctx.field.fieldId}`,
+      `Field: ${ctx.field.fieldName || resolvedFieldName || ctx.field.fieldId}`,
     );
   }
   if ((ctx as any)?.comment?.selectedText) {

package/src/editor/ai/useAgentStatus.ts

@@ -53,10 +53,7 @@ export function useAgentStatus(): AgentStatusSummary {
 
     // Subscribe to WebSocket messages for agent status updates
     const handleMessage = (message: { type: string; payload: any }) => {
-      if (
-        message.type === "agent:status:changed" ||
-        message.type === "agent:run:start"
-      ) {
+      if (message.type === "agent:run:start") {
         // Update agent status in real-time from WebSocket message
         const { agentId, status, name, agentName } = message.payload || {};
         if (!agentId) return;
@@ -111,6 +108,87 @@ export function useAgentStatus(): AgentStatusSummary {
 
           return prevAgents;
         });
+      } else if (message.type === "agent:run:status") {
+        // Unified status updates with data.state
+        const { agentId, data } = message.payload || {};
+        if (!agentId) return;
+
+        const rawState = (data?.state as string | undefined) || undefined;
+        const mappedStatus = ((): Agent["status"] | undefined => {
+          if (!rawState) return undefined;
+          switch (rawState) {
+            case "Running":
+              return "running" as const;
+            case "WaitingForApproval":
+              return "waitingForApproval" as const;
+            case "Completed":
+              return "completed" as const;
+            case "Closed":
+              return "closed" as const;
+            case "Error":
+              return "error" as const;
+            case "Idle":
+              return "idle" as const;
+            case "CostLimitReached":
+              return "costLimitReached" as const;
+            case "Queued":
+              return undefined; // do not show queued in badge
+            default:
+              // allow already-lowercased strings
+              return rawState as any;
+          }
+        })();
+
+        if (!mappedStatus) return;
+
+        setAgents((prevAgents) => {
+          const existingIndex = prevAgents.findIndex((a) => a.id === agentId);
+          const isTerminal =
+            mappedStatus === "completed" ||
+            mappedStatus === "error" ||
+            mappedStatus === "closed";
+
+          if (existingIndex !== -1) {
+            if (isTerminal) {
+              // Remove terminal states from active list
+              return prevAgents.filter((a) => a.id !== agentId);
+            }
+            const updated = [...prevAgents];
+            updated[existingIndex] = {
+              ...updated[existingIndex]!,
+              status: mappedStatus,
+              updatedDate: new Date().toISOString(),
+            };
+            return updated;
+          }
+
+          // Add new if active state
+          if (
+            mappedStatus === "running" ||
+            mappedStatus === "waitingForApproval" ||
+            mappedStatus === "costLimitReached" ||
+            mappedStatus === "idle"
+          ) {
+            const newAgent: Agent = {
+              id: agentId,
+              name: (data?.name as string) || "Agent",
+              userId: "",
+              status: mappedStatus,
+              updatedDate: new Date().toISOString(),
+            };
+            return [...prevAgents, newAgent];
+          }
+
+          return prevAgents;
+        });
+      } else if (message.type === "agent:run:complete") {
+        const { agentId } = message.payload || {};
+        if (!agentId) return;
+        setAgents((prevAgents) => prevAgents.filter((a) => a.id !== agentId));
+      } else if (message.type === "agent:run:error") {
+        const { agentId } = message.payload || {};
+        if (!agentId) return;
+        setAgents((prevAgents) => prevAgents.filter((a) => a.id !== agentId));
       } else if (message.type === "agent:run:closed") {
         // Remove agent from list when it's closed
         const { agentId } = message.payload || {};

package/src/editor/client/EditorShell.tsx

@@ -1229,7 +1229,11 @@ export function EditorShell({
   const loadItem = useCallback(
     async (
       itemToLoad: ItemDescriptor | string,
-      options?: { addToBrowseHistory?: boolean; skipViewChange?: boolean },
+      options?: {
+        addToBrowseHistory?: boolean;
+        skipViewChange?: boolean;
+        skipNavigationHistory?: boolean;
+      },
     ): Promise<FullItem | undefined> => {
       if (typeof itemToLoad === "string")
         itemToLoad = {
@@ -1271,8 +1275,10 @@ export function EditorShell({
         options?.addToBrowseHistory === undefined
       ) {
         addToBrowseHistory(item);
-        // Also add to navigation history with current view
-        addNavigationEntry(viewName, item);
+        // Also add to navigation history with current view (unless skipped)
+        if (!options?.skipNavigationHistory) {
+          addNavigationEntry(viewName, item);
+        }
       }
 
       return item;
@@ -1483,7 +1489,7 @@ export function EditorShell({
 
   const switchView = (
     viewName: string,
-    options?: { skipConfirmation?: boolean },
+    options?: { skipConfirmation?: boolean; skipNavigationHistory?: boolean },
   ) => {
     async function switchView() {
       if (currentView?.beforeClose && !options?.skipConfirmation) {
@@ -1494,8 +1500,10 @@ export function EditorShell({
       // Track previous view name before switching
       setPreviousViewName(editContext.viewName);
 
-      // Add to navigation history with current item
-      addNavigationEntry(viewName, contentEditorItem);
+      // Add to navigation history with current item (unless explicitly skipped)
+      if (!options?.skipNavigationHistory) {
+        addNavigationEntry(viewName, contentEditorItem);
+      }
 
       if (typeof document.startViewTransition === "function") {
         document.startViewTransition(() => {
@@ -1572,6 +1580,20 @@ export function EditorShell({
       field: FieldDescriptor | undefined,
       requestLock: boolean,
     ): Promise<boolean> => {
+      console.log("[setFocusedFieldWithLock] Called with:", {
+        field: field
+          ? {
+              fieldId: field.fieldId,
+              itemId: field.item?.id,
+              language: field.item?.language,
+              version: field.item?.version,
+            }
+          : undefined,
+        requestLock,
+        ignoreBlur,
+        timestamp: new Date().toISOString(),
+      });
+
       if (field) {
         setIgnoreBlur(true);
         setTimeout(() => {
@@ -1579,11 +1601,26 @@ export function EditorShell({
         }, 20);
         setFocusedField({ ...field });
         if (requestLock) {
-          return (await operations.ensureLock(field)) || false;
+          console.log(
+            "[setFocusedFieldWithLock] Calling operations.ensureLock for field:",
+            field.fieldId,
+          );
+          const lockResult = (await operations.ensureLock(field)) || false;
+          console.log(
+            "[setFocusedFieldWithLock] ensureLock result:",
+            lockResult,
+          );
+          return lockResult;
         }
       } else {
+        console.log(
+          "[setFocusedFieldWithLock] Clearing focused field, ignoreBlur:",
+          ignoreBlur,
+        );
         if (!ignoreBlur) {
           setFocusedField(undefined);
+          console.log("[setFocusedFieldWithLock] Clearing lockedField state");
+          setLockedField(undefined); // Clear client-side lock state
           releaseFieldLocks(sessionId);
         }
       }
@@ -1684,7 +1721,12 @@ export function EditorShell({
 
         // First switch view
         if (selectedEntry.viewName !== viewName) {
-          switchView(selectedEntry.viewName, { skipConfirmation: true });
+          // Avoid inserting a duplicate navigation entry; we'll explicitly move the
+          // selected one to the front below
+          switchView(selectedEntry.viewName, {
+            skipConfirmation: true,
+            skipNavigationHistory: true,
+          });
         }
 
         // Then load item if it exists and is different from current
@@ -1706,7 +1748,12 @@ export function EditorShell({
                 language: selectedEntry.item.language,
                 version: selectedEntry.item.version,
               },
-              { addToBrowseHistory: false, skipViewChange: true },
+              {
+                addToBrowseHistory: false,
+                skipViewChange: true,
+                // Avoid inserting an extra nav entry; we move the selected one below
+                skipNavigationHistory: true,
+              },
             );
           } else {
             console.log(`[QuickSwitcher] Same item, skipping reload`);
@@ -2400,6 +2447,8 @@ export function EditorShell({
       isRefreshing,
       activeSessions,
       unlockField: async () => {
+        console.log("[EditContext.unlockField] Clearing lockedField state");
+        setLockedField(undefined); // Clear client-side lock state
         await releaseFieldLocks(sessionId);
       },
       isCommandDisabled: <T extends CommandData>({
@@ -2705,6 +2754,10 @@ export function EditorShell({
       focusedField,
       setFocusedField: setFocusedFieldWithLock,
       unlockField: async () => {
+        console.log(
+          "[FieldsEditContext.unlockField] Clearing lockedField state",
+        );
+        setLockedField(undefined); // Clear client-side lock state
         await releaseFieldLocks(sessionId);
       },
       inlineEditingFieldElement,

package/src/editor/client/operations.ts

@@ -241,27 +241,65 @@ export function getOperationsContext(
 
   const ensureLock = useCallback(
     async (field: FieldDescriptor): Promise<boolean> => {
-      if (!field || !field.item) return false;
-      if (
+      console.log("[ensureLock] Called with field:", {
+        fieldId: field?.fieldId,
+        itemId: field?.item?.id,
+        language: field?.item?.language,
+        version: field?.item?.version,
+        currentLockedField: state.lockedField
+          ? {
+              fieldId: state.lockedField.fieldId,
+              itemId: state.lockedField.item.id,
+              language: state.lockedField.item.language,
+              version: state.lockedField.item.version,
+            }
+          : null,
+        timestamp: new Date().toISOString(),
+      });
+
+      if (!field || !field.item) {
+        console.log(
+          "[ensureLock] Early return: field or field.item is missing",
+        );
+        return false;
+      }
+
+      const isAlreadyLocked =
         state.lockedField?.fieldId === field.fieldId &&
         state.lockedField?.item.id === field.item.id &&
         state.lockedField?.item.language === field.item.language &&
-        state.lockedField?.item.version === field.item.version
-      )
+        state.lockedField?.item.version === field.item.version;
+
+      if (isAlreadyLocked) {
+        console.log(
+          "[ensureLock] Field is already locked, returning true without lockField call",
+        );
         return true;
+      }
+
+      console.log(
+        "[ensureLock] Field is NOT locked, calling lockField service",
+      );
       const result = await lockField(
         field.item,
         field.fieldId,
         state.sessionId,
       );
+      console.log("[ensureLock] lockField service returned:", {
+        resultType: result.type,
+        success: result.type === "success" ? result.data?.success : undefined,
+      });
+
       if (result.type == "error") {
         console.log("error locking field", result);
       }
       if (handleErrorResult(result, ui, state)) return false;
       if (result.type == "success" && result.data.success) {
         state.setLockedField(field);
+        console.log("[ensureLock] Successfully locked field, returning true");
         return true;
       }
+      console.log("[ensureLock] Failed to lock field, returning false");
       return false;
     },
     [state, ui],

package/src/editor/control-center/WebSocketMessages.tsx

@@ -54,7 +54,7 @@ export function WebSocketMessages() {
       "suggested-edit-updated": "bg-indigo-100 text-indigo-800",
       "suggested-edit-deleted": "bg-red-100 text-red-800",
       "update-quota": "bg-gray-100 text-gray-800",
-      "agent:status:changed": "bg-violet-100 text-violet-800",
+
       "agent:run:closed": "bg-red-100 text-red-800",
       "agent:run:start": "bg-green-100 text-green-800",
       "agent:name:updated": "bg-blue-100 text-blue-800",
@@ -158,3 +158,7 @@ export function WebSocketMessages() {
     </div>
   );
 }
+
+
+
+

package/src/editor/page-viewer/PageViewerFrame.tsx

@@ -608,6 +608,14 @@ export function PageViewerFrame({
 
           blockBlurEventRef.current = Date.now() + 500;
 
+          console.log("[PageViewerFrame] Attempting to focus field:", {
+            fieldId: fieldElement.getAttribute("data-fieldid"),
+            itemId: fieldElement.getAttribute("data-itemid"),
+            mode: editContextRef.current?.mode,
+            currentlyFocusedField: fieldsContextRef.current?.focusedField,
+            timestamp: new Date().toISOString(),
+          });
+
           const hasLock =
             editContextRef.current?.mode === "suggestions" ||
             (await fieldsContextRef.current?.setFocusedField(
@@ -615,6 +623,11 @@ export function PageViewerFrame({
               true,
             ));
 
+          console.log("[PageViewerFrame] Focus field result:", {
+            hasLock,
+            fieldId: fieldElement.getAttribute("data-fieldid"),
+          });
+
           if (
             hasLock &&
             fieldsContextRef.current?.inlineEditingFieldElement !== fieldElement
@@ -629,8 +642,8 @@ export function PageViewerFrame({
           fieldsContextRef.current?.setFocusedField(undefined, false);
           fieldsContextRef.current?.setInlineEditingFieldElement(undefined);
           // Release field locks when unfocusing field
-          if (editContextRef.current?.sessionId) {
-            releaseFieldLocks(editContextRef.current.sessionId);
+          if (editContextRef.current?.unlockField) {
+            editContextRef.current.unlockField(undefined as any);
           }
         }
       }

package/src/editor/reviews/commentAi.ts

@@ -52,49 +52,61 @@ export function openAiAgentForComment(
     editContext.setShowAgentsPanel(true);
 
     const initialMetadata: AgentMetadata = {
+      items: [
+        {
+          id:
+            (comment as any).mainItemId ||
+            editContext.currentItemDescriptor?.id!,
+          language: comment.language,
+          version: comment.version,
+          name: editContext.contentEditorItem?.name,
+        },
+      ],
+      components:
+        editContext.selection && editContext.selection.length
+          ? editContext.selection.map((componentId) => ({
+              componentId,
+              pageItem: {
+                id:
+                  (comment as any).mainItemId ||
+                  editContext.currentItemDescriptor?.id!,
+                language: comment.language,
+                version: comment.version,
+                name: editContext.contentEditorItem?.name,
+              },
+            }))
+          : undefined,
+      field:
+        comment.fieldId && comment.itemId
+          ? {
+              fieldId: comment.fieldId,
+              fieldName: comment.fieldName,
+              item: {
+                id: comment.itemId,
+                language: comment.language,
+                version: comment.version,
+                name: comment.itemName,
+              },
+            }
+          : undefined,
+      comment: {
+        id: comment.id,
+        text: comment.text,
+        fieldName: comment.fieldName,
+        itemName: comment.itemName,
+        author: comment.author,
+        selectedText: selectedText,
+        rangeStart: comment.rangeStart,
+        rangeEnd: comment.rangeEnd,
+      },
       additionalData: {
         initialPrompt,
-        context: {
-          pages: [
-            {
-              id:
-                (comment as any).mainItemId ||
-                editContext.currentItemDescriptor?.id!,
-              language: comment.language,
-              version: comment.version,
-              name: editContext.contentEditorItem?.name,
-            } as any,
-          ],
-          componentIds:
-            editContext.selection && editContext.selection.length
-              ? editContext.selection
-              : undefined,
-          field:
-            comment.fieldId && comment.itemId
-              ? {
-                  fieldId: comment.fieldId,
-                  itemId: comment.itemId,
-                  name: comment.fieldName,
-                }
-              : undefined,
-          comment: {
-            id: comment.id,
-            text: comment.text,
-            fieldName: comment.fieldName,
-            itemName: comment.itemName,
-            author: comment.author,
-            selectedText: selectedText,
-            rangeStart: comment.rangeStart,
-            rangeEnd: comment.rangeEnd,
-          },
-        },
-        // Seed profile from editor settings if available
         profileId:
           editContext.editorSettings?.commentResolveProfileId || undefined,
         profileName:
           editContext.editorSettings?.commentResolveProfileName || undefined,
       },
-    } as any;
+    };
 
     // Ask Agents UI to open a new terminal seeded with this metadata
     try {