Adding --dev-frontend to studioctl build as well, and using those when running github workflows

Author: Ole Martin Handeland

.github/actions/app-run-local-env/action.yaml

@@ -121,7 +121,7 @@ runs:
           }
 
           function targetRunArgs(path, image) {
-            const args = ['run', '--mode', 'container', '--detach', '--random-host-port', '--path', path];
+            const args = ['run', '--mode', 'container', '--detach', '--random-host-port', '--dev-frontend', '--path', path];
             if (image) {
               args.push('--image-tag', image, '--pull', '--skip-build');
             }

.github/workflows/app-frontend-cypress.yml

@@ -100,7 +100,7 @@ jobs:
               while (nextTarget < targets.length) {
                 const target = targets[nextTarget++];
                 core.info(`Worker ${workerId}: building ${target.path}`);
-                await exec.exec('studioctl', ['app', 'build', '--path', target.path, '--image-tag', target.image, '--push']);
+                await exec.exec('studioctl', ['app', 'build', '--path', target.path, '--image-tag', target.image, '--push', '--dev-frontend']);
               }
             }
 

src/cli/internal/appimage/spec.go

@@ -35,6 +35,30 @@ type BuildSpec struct {
 	Build             types.BuildOptions
 }
 
+// SetAppFrontendAssetBaseURL injects a frontend asset base URL into the built app image.
+func SetAppFrontendAssetBaseURL(spec *BuildSpec, value string) error {
+	if value == "" {
+		return nil
+	}
+
+	content := spec.DockerfileContent
+	if content == "" {
+		data, err := os.ReadFile(spec.Dockerfile)
+		if err != nil {
+			return fmt.Errorf("read dockerfile: %w", err)
+		}
+		content = string(data)
+	}
+
+	if !strings.HasSuffix(content, "\n") {
+		content += "\n"
+	}
+	content += "ENV AppSettings__AppFrontendAssetBaseUrl=" + value + "\n"
+	spec.Dockerfile = ""
+	spec.DockerfileContent = content
+	return nil
+}
+
 // BuildSpecForApp builds image build configuration for an app container.
 func BuildSpecForApp(result repocontext.Detection, imageTag string) (BuildSpec, error) {
 	runRepo, err := newRepoContext(result)

src/cli/internal/appimage/spec_test.go

@@ -242,6 +242,38 @@ func TestBuildSpecForApp_StandaloneAppInjectsConfigCopy(t *testing.T) {
 	assertInOrder(t, spec.DockerfileContent, []string{publish, copyConfig, final})
 }
 
+func TestSetAppFrontendAssetBaseURL_AppendsEnvToFinalStage(t *testing.T) {
+	t.Parallel()
+
+	appRoot := t.TempDir()
+	writeTestAppDockerfile(t, appRoot, "Altinn.Application.dll")
+
+	spec, err := appimage.BuildSpecForApp(repocontext.Detection{
+		AppRoot:   appRoot,
+		InAppRepo: true,
+	}, "")
+	if err != nil {
+		t.Fatalf("BuildSpecForApp() error = %v", err)
+	}
+
+	want := "http://app-frontend.local.altinn.cloud:8000"
+	if err := appimage.SetAppFrontendAssetBaseURL(&spec, want); err != nil {
+		t.Fatalf("SetAppFrontendAssetBaseURL() error = %v", err)
+	}
+
+	if spec.Dockerfile != "" {
+		t.Fatalf("Dockerfile = %q, want generated dockerfile", spec.Dockerfile)
+	}
+	assertContainsAll(t, spec.DockerfileContent, []string{
+		"ENV AppSettings__AppFrontendAssetBaseUrl=" + want,
+	})
+	assertInOrder(t, spec.DockerfileContent, []string{
+		"FROM mcr.microsoft.com/dotnet/aspnet:10.0-alpine AS final",
+		`ENTRYPOINT ["dotnet","Altinn.Application.dll"]`,
+		"ENV AppSettings__AppFrontendAssetBaseUrl=" + want,
+	})
+}
+
 func TestBuildSpecForApp_StandaloneAppDoesNotDuplicateExistingConfigCopy(t *testing.T) {
 	t.Parallel()
 

src/cli/internal/cmd/app.go

@@ -16,6 +16,7 @@ import (
 	appsvc "altinn.studio/studioctl/internal/cmd/app"
 	"altinn.studio/studioctl/internal/config"
 	repocontext "altinn.studio/studioctl/internal/context"
+	"altinn.studio/studioctl/internal/envtopology"
 	"altinn.studio/studioctl/internal/osutil"
 	"altinn.studio/studioctl/internal/studio"
 	"altinn.studio/studioctl/internal/studioctlserver"
@@ -48,6 +49,7 @@ type appBuildFlags struct {
 	mode       string
 	imageTag   string
 	push       bool
+	devFrontend bool
 	jsonOutput bool
 }
 
@@ -167,6 +169,9 @@ func (c *AppCommand) runBuild(ctx context.Context, args []string) error {
 	if err != nil {
 		return fmt.Errorf("build docker image spec: %w", err)
 	}
+	if err := appimage.SetAppFrontendAssetBaseURL(&spec, appBuildFrontendAssetBaseURL(flags)); err != nil {
+		return fmt.Errorf("set app frontend asset base URL: %w", err)
+	}
 	cleanupDockerfile, err := appimage.MaterializeDockerfile(&spec)
 	if err != nil {
 		return fmt.Errorf("materialize dockerfile: %w", err)
@@ -213,6 +218,7 @@ func (c *AppCommand) parseAppBuildFlags(args []string) (appBuildFlags, bool, err
 	fs.StringVar(&flags.mode, "mode", runModeContainer, "Build mode")
 	fs.StringVar(&flags.imageTag, "image-tag", "", "App container image tag")
 	fs.BoolVar(&flags.push, "push", false, "Push app container image after build")
+	fs.BoolVar(&flags.devFrontend, "dev-frontend", false, "Use frontend dev server assets")
 	fs.BoolVar(&flags.jsonOutput, "json", false, "Output as JSON")
 
 	if err := fs.Parse(args); err != nil {
@@ -240,13 +246,22 @@ func (c *AppCommand) appBuildUsage() string {
 		"Options:",
 		"  -p, --path PATH       Specify app directory (overrides auto-detect)",
 		"  -m, --mode MODE       Build mode: container (default: container)",
+		"  --dev-frontend        Use frontend dev server assets",
 		"  --image-tag IMAGE     App container image tag",
 		"  --push                Push app container image after build",
 		"  --json                Output as JSON",
 		"  -h, --help            Show this help",
 	)
 }
 
+func appBuildFrontendAssetBaseURL(flags appBuildFlags) string {
+	if !flags.devFrontend {
+		return ""
+	}
+	topology := envtopology.NewLocal(envtopology.DefaultIngressPortString())
+	return topology.PublicBaseURL(envtopology.ComponentFrontendDevServer)
+}
+
 func (c *AppCommand) runUpdate(ctx context.Context, args []string) error {
 	fs := flag.NewFlagSet("app update", flag.ContinueOnError)
 	var appPath string

src/cli/internal/cmd/app_build_test.go

@@ -0,0 +1,32 @@
+package cmd
+
+import (
+	"io"
+	"testing"
+
+	"altinn.studio/studioctl/internal/envtopology"
+	"altinn.studio/studioctl/internal/ui"
+)
+
+func TestParseAppBuildFlagsReadsDevFrontend(t *testing.T) {
+	t.Parallel()
+
+	cmd := &AppCommand{out: ui.NewOutput(io.Discard, io.Discard, false)}
+	flags, _, err := cmd.parseAppBuildFlags([]string{"--dev-frontend"})
+	if err != nil {
+		t.Fatalf("parseAppBuildFlags() error = %v", err)
+	}
+	if !flags.devFrontend {
+		t.Fatal("devFrontend = false, want true")
+	}
+}
+
+func TestAppBuildFrontendAssetBaseURLUsesTopologyFrontendDevServer(t *testing.T) {
+	t.Parallel()
+
+	got := appBuildFrontendAssetBaseURL(appBuildFlags{devFrontend: true})
+	want := envtopology.NewLocal(envtopology.DefaultIngressPortString()).PublicBaseURL(envtopology.ComponentFrontendDevServer)
+	if got != want {
+		t.Fatalf("appBuildFrontendAssetBaseURL() = %q, want %q", got, want)
+	}
+}

src/cli/internal/cmd/run.go

@@ -1217,6 +1217,7 @@ func (c *RunCommand) runDocker(
 		ctx,
 		client,
 		result,
+		topology,
 		spec.Config.Image,
 		flags,
 		progress,
@@ -1439,6 +1440,7 @@ func (c *RunCommand) prepareDockerRunImage(
 	ctx context.Context,
 	client containerruntime.ContainerClient,
 	result repocontext.Detection,
+	topology envtopology.Local,
 	imageTag string,
 	flags runFlags,
 	progress *containerRunProgress,
@@ -1462,6 +1464,9 @@ func (c *RunCommand) prepareDockerRunImage(
 	if err != nil {
 		return fmt.Errorf("build docker image spec: %w", err)
 	}
+	if err := appimage.SetAppFrontendAssetBaseURL(&spec, runAppFrontendAssetBaseUrl(topology, flags)); err != nil {
+		return fmt.Errorf("set app frontend asset base URL: %w", err)
+	}
 	cleanupDockerfile, prepareErr := appimage.MaterializeDockerfile(&spec)
 	if prepareErr != nil {
 		return fmt.Errorf("materialize dockerfile: %w", prepareErr)

src/cli/internal/cmd/run_internal_test.go

@@ -391,7 +391,15 @@ func TestPrepareDockerRunImagePullUsesProgressRenderer(t *testing.T) {
 		return nil
 	}
 
-	err := cmd.prepareDockerRunImage(t.Context(), client, repocontext.Detection{}, flags.imageTag, flags, progress)
+	err := cmd.prepareDockerRunImage(
+		t.Context(),
+		client,
+		repocontext.Detection{},
+		envtopology.NewLocal(envtopology.DefaultIngressPortString()),
+		flags.imageTag,
+		flags,
+		progress,
+	)
 	if err != nil {
 		t.Fatalf("prepareDockerRunImage() error = %v", err)
 	}