no deployed workflow case

Author: icecrasher321

apps/sim/app/workspace/[workspaceId]/w/components/sidebar/components/workspace-header/components/fork-workspace-modal/fork-workspace-modal.tsx

@@ -28,7 +28,7 @@ interface ForkWorkspaceModalProps {
   sourceWorkspaceName: string
 }
 
-type ResourceKey = keyof GetForkResourcesResponse
+type ResourceKey = Exclude<keyof GetForkResourcesResponse, 'deployedWorkflowCount'>
 type ResourceSelection = Record<ResourceKey, Set<string>>
 
 const RESOURCE_KINDS: ReadonlyArray<{ key: ResourceKey; label: string }> = [
@@ -188,6 +188,13 @@ export function ForkWorkspaceModal({
     [resources.data]
   )
 
+  // A fork always produces a usable workspace: deployed workflows are copied, and
+  // when the source has none, create-fork seeds a blank starter workflow (plus any
+  // selected resources). So forking is never blocked - we just set expectations when
+  // there are no deployed workflows to carry over.
+  const noDeployedWorkflows =
+    Boolean(resources.data) && (resources.data?.deployedWorkflowCount ?? 0) === 0
+
   const handleSubmit = () => {
     const trimmed = name.trim()
     if (!trimmed || isForking) return
@@ -258,12 +265,17 @@ export function ForkWorkspaceModal({
                   disabled={isForking}
                 />
               ))}
-              <p className='text-[var(--text-secondary)] text-xs'>
+              <p className='text-[var(--text-muted)] text-caption'>
                 Unselected resources leave their workflow fields empty in the fork.
               </p>
             </div>
           </ChipModalField>
         ) : null}
+        {noDeployedWorkflows ? (
+          <p className='px-2 text-[var(--text-muted)] text-caption'>
+            No deployed workflows to copy — your fork will start with a blank workflow.
+          </p>
+        ) : null}
         <ChipModalError>{error ?? undefined}</ChipModalError>
       </ChipModalBody>
       <ChipModalFooter

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

@@ -121,6 +121,7 @@ export const getForkResourcesContract = defineRouteContract({
       customTools: z.array(forkCopyableResourceSchema),
       skills: z.array(forkCopyableResourceSchema),
       mcpServers: z.array(forkCopyableResourceSchema),
+      deployedWorkflowCount: z.number().int(),
     }),
   },
 })

apps/sim/lib/workspaces/fork/create-fork.ts

@@ -1,12 +1,14 @@
 import { db } from '@sim/db'
-import { permissions, workspace } from '@sim/db/schema'
+import { permissions, workflow, workspace } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import type { PermissionType } from '@sim/platform-authz/workspace'
 import { generateId } from '@sim/utils/id'
 import { and, eq } from 'drizzle-orm'
 import type { Workspace } from '@/lib/api/contracts/workspaces'
 import { isTriggerDevEnabled } from '@/lib/core/config/env-flags'
 import { runDetached } from '@/lib/core/utils/background'
+import { buildDefaultWorkflowArtifacts } from '@/lib/workflows/defaults'
+import { saveWorkflowToNormalizedTables } from '@/lib/workflows/persistence/utils'
 import {
   type ForkContentCopyPayload,
   runForkContentCopy,
@@ -209,6 +211,30 @@ export async function createFork(params: CreateForkParams): Promise<CreateForkRe
       workflowsCopied += 1
     }
 
+    // A fork carries only DEPLOYED workflows. When the source has none (e.g. it was
+    // itself just forked and never redeployed), seed a default workflow so the child
+    // is a usable workspace rather than a blank one with no workflow at all - the same
+    // starter "New workspace" creates. Any copied resources still land alongside it.
+    if (workflowsCopied === 0) {
+      const defaultWorkflowId = generateId()
+      await tx.insert(workflow).values({
+        id: defaultWorkflowId,
+        userId,
+        workspaceId: childWorkspaceId,
+        folderId: null,
+        name: 'default-agent',
+        description: 'Your first workflow - start building here!',
+        lastSynced: now,
+        createdAt: now,
+        updatedAt: now,
+        isDeployed: false,
+        runCount: 0,
+        variables: {},
+      })
+      const { workflowState } = buildDefaultWorkflowArtifacts()
+      await saveWorkflowToNormalizedTables(defaultWorkflowId, workflowState, tx)
+    }
+
     const seedEntries: ForkMappingUpsert[] = []
     for (const [sourceWorkflowId, childWorkflowId] of workflowIdMap.entries()) {
       seedEntries.push({

apps/sim/lib/workspaces/fork/mapping/resources.ts

@@ -5,10 +5,11 @@ import {
   mcpServers,
   skill,
   userTableDefinitions,
+  workflow,
   workspaceEnvironment,
   workspaceFiles,
 } from '@sim/db/schema'
-import { and, eq, isNull, sql } from 'drizzle-orm'
+import { and, count, eq, isNull, sql } from 'drizzle-orm'
 import type { DbOrTx } from '@/lib/db/types'
 import type { ForkResourceType } from '@/lib/workspaces/fork/mapping/mapping-store'
 import type { ForkRemapKind } from '@/lib/workspaces/fork/remap/remap-references'
@@ -123,6 +124,12 @@ export interface ForkCopyableResources {
   customTools: ForkResourceCandidate[]
   skills: ForkResourceCandidate[]
   mcpServers: ForkResourceCandidate[]
+  /**
+   * Count of deployed workflows that the fork would copy. The fork modal disables
+   * the action (with a reason) when this is 0 and there are no copyable resources,
+   * since the fork would otherwise produce an empty workspace.
+   */
+  deployedWorkflowCount: number
 }
 
 /**
@@ -134,7 +141,7 @@ export async function listForkCopyableResources(
   executor: DbOrTx,
   workspaceId: string
 ): Promise<ForkCopyableResources> {
-  const [files, tables, kbs, tools, skills, servers] = await Promise.all([
+  const [files, tables, kbs, tools, skills, servers, deployed] = await Promise.all([
     executor
       .select({
         id: workspaceFiles.id,
@@ -174,6 +181,16 @@ export async function listForkCopyableResources(
       .from(mcpServers)
       .where(and(eq(mcpServers.workspaceId, workspaceId), isNull(mcpServers.deletedAt)))
       .limit(CANDIDATE_LIMIT),
+    executor
+      .select({ value: count() })
+      .from(workflow)
+      .where(
+        and(
+          eq(workflow.workspaceId, workspaceId),
+          eq(workflow.isDeployed, true),
+          isNull(workflow.archivedAt)
+        )
+      ),
   ])
   return {
     files,
@@ -182,6 +199,7 @@ export async function listForkCopyableResources(
     customTools: tools,
     skills,
     mcpServers: servers,
+    deployedWorkflowCount: deployed[0]?.value ?? 0,
   }
 }