fix(forks): label a failed fill honestly, count skills and documents, and surface deploy warnings on the sync row

Author: icecrasher321

apps/sim/ee/workspace-forking/components/fork-activity-panel/fork-activity-panel.test.tsx

@@ -220,6 +220,55 @@ describe('ForkActivityPanel sync report', () => {
     expect(container.textContent).toContain('2 tables, 1 file')
   })
 
+  it('shows a fill of only skills and documents, which carry no table or file count', () => {
+    renderJobs([
+      makeJob({
+        kind: 'fork_sync',
+        workspaceId: WORKSPACE_ID,
+        status: 'processing',
+        metadata: { ...syncMetadata, tables: 0, files: 0, skills: 1, documents: 2 },
+      }),
+    ])
+
+    expandRow()
+    expect(container.textContent).toContain('Copying')
+    expect(container.textContent).toContain('2 documents, 1 skill')
+  })
+
+  it('does not call a fill copied when the row failed before it finished', () => {
+    renderJobs([
+      makeJob({
+        kind: 'fork_sync',
+        workspaceId: WORKSPACE_ID,
+        status: 'failed',
+        error: 'Background resource copy failed',
+        metadata: syncMetadata,
+      }),
+    ])
+
+    expandRow()
+    expect(container.textContent).toContain('Copy failed')
+    expect(container.textContent).toContain('2 tables, 1 file')
+    expect(container.textContent).not.toContain('Copied')
+  })
+
+  it('surfaces a deploy that succeeded with its cutover still pending', () => {
+    renderJobs([
+      makeJob({
+        kind: 'fork_sync',
+        workspaceId: WORKSPACE_ID,
+        status: 'completed_with_warnings',
+        metadata: {
+          ...syncMetadata,
+          deployWarnings: ['Flow A — prior workflow version remains active'],
+        },
+      }),
+    ])
+
+    expandRow()
+    expect(container.textContent).toContain('Flow A — prior workflow version remains active')
+  })
+
   it('reports the finished copy and what it lost on the same row', () => {
     renderJobs([
       makeJob({

apps/sim/ee/workspace-forking/components/fork-activity-panel/fork-activity-panel.tsx

@@ -38,12 +38,31 @@ function countList(pairs: Array<[number | undefined, string]>): string {
 function contentFillCounts(m: NonNullable<BackgroundWorkMetadata>): string[] {
   const kinds: Array<[number | undefined, string]> = [
     [m.knowledgeBases, 'knowledge base'],
+    [m.documents, 'document'],
     [m.tables, 'table'],
     [m.files, 'file'],
+    [m.skills, 'skill'],
   ]
   return kinds.filter(([n]) => (n ?? 0) > 0).map(([n, noun]) => plural(n as number, noun))
 }
 
+/**
+ * Label for a sync's background content fill, by where the row is in it. A failed row keeps
+ * the counts it planned, so they must not read as copied: the fill was never scheduled, or
+ * died before finishing, and the row's error says which.
+ */
+function contentFillLabel(status: BackgroundWorkItem['status']): string {
+  switch (status) {
+    case 'pending':
+    case 'processing':
+      return 'Copying'
+    case 'failed':
+      return 'Copy failed'
+    default:
+      return 'Copied'
+  }
+}
+
 /** A named group (one resource kind or change action) of a job's report. */
 interface ReportGroup {
   label: string
@@ -188,7 +207,7 @@ function jobReport(job: BackgroundWorkItem): JobReport {
     addGroup('Created', m.createdNames)
     addGroup('Archived', m.archivedNames)
     // Resources the sync copied have their content filled in the background on this same row.
-    addGroup(job.status === 'processing' ? 'Copying' : 'Copied', contentFillCounts(m))
+    addGroup(contentFillLabel(job.status), contentFillCounts(m))
     // Pre-names entries fall back to the count summary (redeployed mirrors updated).
     if (groups.length === 0) {
       const counts = countList([
@@ -216,6 +235,7 @@ function jobReport(job: BackgroundWorkItem): JobReport {
     if (m.deployFailed && m.deployFailed > 0) {
       notes.push({ value: `${plural(m.deployFailed, 'workflow')} failed to deploy`, warning: true })
     }
+    for (const warning of m.deployWarnings ?? []) notes.push({ value: warning, warning: true })
     addContentFillWarnings()
     return { groups, notes }
   }

apps/sim/ee/workspace-forking/lib/create-fork.ts

@@ -560,6 +560,8 @@ export async function createFork(params: CreateForkParams): Promise<CreateForkRe
         tables: contentPlan.tables.length,
         knowledgeBases: contentPlan.knowledgeBases.length,
         files: blobTasks.length,
+        skills: contentPlan.skills.length,
+        documents: contentPlan.documents.length,
         workflowNames: forkedWorkflowNames,
         tableNames: forkedResourceNames.tables,
         knowledgeBaseNames: forkedResourceNames.knowledgeBases,

apps/sim/ee/workspace-forking/lib/promote/promote.test.ts

@@ -159,6 +159,7 @@ vi.mock('@/lib/workspaces/permissions/utils', () => ({
 }))
 
 import { db } from '@sim/db'
+import { performFullDeploy } from '@/lib/workflows/orchestration/deploy'
 import { getBlock } from '@/blocks/registry'
 import {
   recordBackgroundWork,
@@ -229,6 +230,39 @@ function promoteParams() {
   }
 }
 
+/** One deployed source workflow the sync writes (replace mode) and then deploys. */
+function arrangeWrittenWorkflow() {
+  mockComputePlan.mockResolvedValue(
+    makePlan({
+      items: [
+        {
+          sourceWorkflowId: 'wf-src',
+          targetWorkflowId: 'wf-tgt',
+          targetName: 'Flow',
+          mode: 'replace' as const,
+          sourceMeta: { name: 'Flow', description: null, folderId: null, sortOrder: 0 },
+        },
+      ],
+    })
+  )
+  mockLoadSourceDeployedStates.mockResolvedValue({
+    deployedWorkflows: [],
+    sourceStates: new Map([
+      ['wf-src', { blocks: {}, edges: [], loops: {}, parallels: {}, variables: {} }],
+    ]),
+  })
+  vi.mocked(copyWorkflowStateIntoTarget).mockResolvedValue({
+    targetWorkflowId: 'wf-tgt',
+    mode: 'replace',
+    name: 'Flow',
+    blocksCount: 0,
+    edgesCount: 0,
+    subflowsCount: 0,
+    clearedDependents: [],
+    blockIdMapping: new Map(),
+  })
+}
+
 /** A copy result carrying no content/id maps, for tests that only need the copy to run. */
 function emptyCopyResult() {
   return {
@@ -830,6 +864,27 @@ describe('promoteFork trigger URLs', () => {
 })
 
 describe('promoteFork activity', () => {
+  it('records a deploy that succeeded with a warning as a sync with warnings', async () => {
+    arrangeWrittenWorkflow()
+    vi.mocked(performFullDeploy).mockResolvedValueOnce({
+      success: true,
+      warnings: ['prior workflow version remains active'],
+    } as never)
+
+    const result = await promoteFork(promoteParams())
+
+    expect(result.deployWarnings).toEqual(['Flow — prior workflow version remains active'])
+    expect(recordBackgroundWork).toHaveBeenCalledWith(
+      db,
+      expect.objectContaining({
+        status: 'completed_with_warnings',
+        metadata: expect.objectContaining({
+          deployWarnings: ['Flow — prior workflow version remains active'],
+        }),
+      })
+    )
+  })
+
   it('records the sync as one terminal Activity row when nothing is left to fill', async () => {
     await promoteFork(promoteParams())
 
@@ -882,6 +937,8 @@ describe('promoteFork activity', () => {
           tables: 1,
           knowledgeBases: 0,
           files: 0,
+          skills: 0,
+          documents: 0,
         }),
       })
     )

apps/sim/ee/workspace-forking/lib/promote/promote.ts

@@ -165,6 +165,12 @@ export interface PromoteForkResult {
    * until a redeploy. Surfaced (rather than swallowed) so the caller can warn.
    */
   deployFailed: number
+  /**
+   * Deploys that succeeded but left something pending - a cutover still activating, a side
+   * effect still queued - as `<workflow> — <warning>`. The target is not yet running what the
+   * sync wrote, so the sync's Activity row must not read as clean.
+   */
+  deployWarnings: string[]
   unmappedRequired: Array<Pick<ForkReference, 'kind' | 'sourceId' | 'required' | 'blockName'>>
   /**
    * References the sync would have cleared in the target, so it was blocked without writing
@@ -225,6 +231,7 @@ function buildSyncActivity(
   const { direction, sourceWorkspaceId, targetWorkspaceId, otherWorkspaceName, actorName } = params
   const warnings =
     result.deployFailed > 0 ||
+    result.deployWarnings.length > 0 ||
     result.needsConfiguration.length > 0 ||
     result.clearedOptional.length > 0 ||
     result.droppedReferences.length > 0 ||
@@ -246,6 +253,7 @@ function buildSyncActivity(
       archived: result.archived,
       redeployed: result.redeployed,
       deployFailed: result.deployFailed,
+      deployWarnings: result.deployWarnings,
       updatedNames: result.updatedNames,
       createdNames: result.createdNames,
       archivedNames: result.archivedNames,
@@ -1059,6 +1067,7 @@ export async function promoteFork(params: PromoteForkParams): Promise<PromoteFor
       archived: 0,
       redeployed: 0,
       deployFailed: 0,
+      deployWarnings: [],
       unmappedRequired: txResult.blocked === 'unmapped' ? txResult.unmappedRequired : [],
       blockers: txResult.blocked === 'cleared-refs' ? txResult.blockers : [],
       blocked: txResult.blocked,
@@ -1117,7 +1126,7 @@ export async function promoteFork(params: PromoteForkParams): Promise<PromoteFor
         // sync). Surface those instead of swallowing them into a clean success.
         if (result.warnings?.length) {
           const name = txResult.writtenNames[targetWorkflowId] ?? targetWorkflowId
-          for (const warning of result.warnings) deployWarnings.push(`${name}: ${warning}`)
+          for (const warning of result.warnings) deployWarnings.push(`${name} — ${warning}`)
         }
       } else {
         deployFailures.push(targetWorkflowId)
@@ -1142,6 +1151,7 @@ export async function promoteFork(params: PromoteForkParams): Promise<PromoteFor
     archived: txResult.archived,
     redeployed,
     deployFailed: deployFailures.length,
+    deployWarnings,
     unmappedRequired: [],
     blockers: [],
     blocked: null,
@@ -1197,6 +1207,8 @@ export async function promoteFork(params: PromoteForkParams): Promise<PromoteFor
           tables: contentFill.contentPlan.tables.length,
           knowledgeBases: contentFill.contentPlan.knowledgeBases.length,
           files: contentFill.blobTasks.length,
+          skills: contentFill.contentPlan.skills.length,
+          documents: contentFill.contentPlan.documents.length,
         },
       })
     } else {

apps/sim/lib/api/contracts/workspace-fork.ts

@@ -785,6 +785,9 @@ export const backgroundWorkMetadataSchema = z
     tables: z.number().int().optional(),
     knowledgeBases: z.number().int().optional(),
     files: z.number().int().optional(),
+    skills: z.number().int().optional(),
+    /** Documents copied into an already-mapped target knowledge base (sync only). */
+    documents: z.number().int().optional(),
     copied: z.number().int().optional(),
     failed: z.number().int().optional(),
     /** Count of failed resources whose dangling references were cleared post-fork (U8). */
@@ -814,6 +817,8 @@ export const backgroundWorkMetadataSchema = z
     archived: z.number().int().optional(),
     redeployed: z.number().int().optional(),
     deployFailed: z.number().int().optional(),
+    /** Deploys that succeeded with a cutover or side effect still pending, as `<workflow> — <warning>`. */
+    deployWarnings: z.array(z.string()).optional(),
     restored: z.number().int().optional(),
     unarchived: z.number().int().optional(),
     removed: z.number().int().optional(),