feat: ship single-file run distribution and list key reset

Compile-time run auth replaces zip sidecars, lengthens run keys, revokes
active sessions on reset, and exposes run-key reset in the server list.

platform/service/distributions_test.go

@@ -35,7 +35,7 @@ func TestCoreServiceGeneratesRunDistributionWithEncryptedSingletonKey(t *testing
 	if err != nil {
 		t.Fatalf("generate run distribution: %v", err)
 	}
-	if distribution.KeyGeneration != 1 || distribution.SecretRef == "" || distribution.Status != domain.DistributionStatusBuilding || distribution.BuildJobID == "" || distribution.Checksum != "" {
+	if distribution.KeyGeneration != 1 || distribution.SecretRef == "" || distribution.PackageFormat != "raw-executable" || distribution.Status != domain.DistributionStatusBuilding || distribution.BuildJobID == "" || distribution.Checksum != "" {
 		t.Fatalf("unexpected run distribution: %+v", distribution)
 	}
 	job, err := svc.GetJob(distribution.BuildJobID)
@@ -62,6 +62,9 @@ func TestCoreServiceGeneratesRunDistributionWithEncryptedSingletonKey(t *testing
 	if config.AuthKey == "" || config.AuthKey == keys[0].EncryptedKey || strings.Contains(distribution.SecretRef, config.AuthKey) {
 		t.Fatalf("run package key leaked through metadata or was not encrypted, config=%+v key=%+v distribution=%+v", config, keys[0], distribution)
 	}
+	if len(config.AuthKey) < 80 {
+		t.Fatalf("expected longer run component key, got length %d", len(config.AuthKey))
+	}
 	auth, err := svc.AuthenticateComponent(domain.ComponentAuthenticationRequest{
 		ServerInstanceID: instance.ID,
 		ComponentKind:    domain.DistributionComponentRun,
@@ -159,6 +162,7 @@ func TestCoreServiceRuntimeActionsGateDependenciesOnPluginPermission(t *testing.
 }
 
 func TestCoreServiceDistributionBuildRejectsPrematureSuccessAndCanRetryAfterUpload(t *testing.T) {
+	t.Setenv("PLATFORM_RUN_RELEASE_URL", "https://scum.npc0.com")
 	svc, session, instance := newDistributionTestFixture(t)
 	distribution, err := svc.GenerateRunDistributionForSession(session, domain.RunDistributionGenerateRequest{
 		ServerInstanceID: instance.ID,
@@ -185,6 +189,19 @@ func TestCoreServiceDistributionBuildRejectsPrematureSuccessAndCanRetryAfterUplo
 	if err != nil || !claim.HasJob || claim.Job.JobID != distribution.BuildJobID {
 		t.Fatalf("claim distribution build job: claim=%+v err=%v", claim, err)
 	}
+	buildInput, err := svc.GetDistributionBuildInput(domain.DistributionBuildInputRequest{
+		RunEndpointID: claim.Job.RunEndpointID,
+		SessionToken:  hello.SessionToken,
+		JobID:         claim.Job.JobID,
+		LeaseToken:    claim.Job.LeaseToken,
+		Attempt:       claim.Job.Attempt,
+	})
+	if err != nil {
+		t.Fatalf("get distribution build input: %v", err)
+	}
+	if buildInput.PlatformURL != "https://scum.npc0.com" || buildInput.PackageFormat != "raw-executable" || buildInput.AuthKey == "" || len(buildInput.AuthKey) < 80 {
+		t.Fatalf("expected raw executable build input with release URL and long key, got %+v", buildInput)
+	}
 	result := domain.RunJobResult{
 		RunEndpointID: instance.RunEndpointID,
 		SessionToken:  hello.SessionToken,
@@ -227,14 +244,14 @@ func TestCoreServiceRunDistributionDownloadUsesTargetPackageName(t *testing.T) {
 	if err != nil {
 		t.Fatalf("generate run distribution: %v", err)
 	}
-	payload := []byte("windows zipped run package")
+	payload := []byte("windows raw run executable")
 	completeDistributionBuild(t, svc, distribution, payload)
 
 	reference, err := svc.OpenArtifactDownloadForSession(session, domain.ArtifactDownloadReferenceRequest{ArtifactID: distribution.ArtifactID})
 	if err != nil {
 		t.Fatalf("open run artifact download: %v", err)
 	}
-	if reference.Filename != "run-windows-amd64.zip" || reference.ContentType != "application/zip" {
+	if reference.Filename != "run-windows-amd64.exe" || reference.ContentType != "application/octet-stream" {
 		t.Fatalf("expected windows run package metadata, got %+v", reference)
 	}
 
@@ -275,7 +292,7 @@ func TestCoreServiceRunDistributionRetryReusesPartialArtifact(t *testing.T) {
 	if distribution.ID != distributionID || distribution.ArtifactID == partialArtifact.ID || distribution.Checksum != "" {
 		t.Fatalf("expected real binary build to ignore legacy config artifact, distribution=%+v artifact=%+v", distribution, partialArtifact)
 	}
-	if distribution.PackageFormat != "zip" || distribution.Status != domain.DistributionStatusBuilding || distribution.BuildJobID == "" {
+	if distribution.PackageFormat != "raw-executable" || distribution.Status != domain.DistributionStatusBuilding || distribution.BuildJobID == "" {
 		t.Fatalf("unexpected recovered distribution: %+v", distribution)
 	}
 	recoveredConfig := readGeneratedPackageConfig(t, svc, session, distribution.ArtifactID)
@@ -332,6 +349,17 @@ func TestCoreServiceResetRunKeyRevokesOldPackagesAndRequiresRegeneration(t *test
 	}
 	oldConfig := readGeneratedPackageConfig(t, svc, session, distribution.ArtifactID)
 	distribution = completeDistributionBuild(t, svc, distribution, []byte("compiled run archive before reset"))
+	helloRequest := validRunControlHello()
+	helloRequest.RunEndpointID = instance.RunEndpointID
+	helloRequest.RegistrationToken = oldConfig.AuthKey
+	helloRequest.ServerInstanceID = instance.ID
+	helloRequest.PluginID = instance.PluginID
+	helloRequest.ComponentKind = domain.DistributionComponentRun
+	helloRequest.KeyGeneration = oldConfig.KeyGeneration
+	hello, err := svc.RegisterRunHello(helloRequest)
+	if err != nil || !hello.Accepted {
+		t.Fatalf("register old run before reset: hello=%+v err=%v", hello, err)
+	}
 
 	reset, err := svc.ResetComponentKeyForSession(session, domain.ComponentKeyResetRequest{
 		ServerInstanceID: instance.ID,
@@ -343,6 +371,27 @@ func TestCoreServiceResetRunKeyRevokesOldPackagesAndRequiresRegeneration(t *test
 	if reset.Generation != 2 || reset.Status != domain.ComponentKeyStatusActive {
 		t.Fatalf("expected reset key generation 2, got %+v", reset)
 	}
+	if _, err := svc.AcceptRunHeartbeat(domain.RunControlHeartbeat{
+		RunEndpointID:         instance.RunEndpointID,
+		SessionToken:          hello.SessionToken,
+		Status:                domain.RunEndpointStatusOnline,
+		Version:               "stale-run",
+		Capacity:              domain.RunCapacity{MaxJobs: 1},
+		CapabilityFingerprint: helloRequest.CapabilityReport.Fingerprint,
+	}); err == nil {
+		t.Fatal("expected reset to revoke the active run control session")
+	}
+	endpoint, err := svc.store.RunEndpoints().Get(instance.RunEndpointID)
+	if err != nil {
+		t.Fatalf("get endpoint after reset: %v", err)
+	}
+	if endpoint.Status != domain.RunEndpointStatusOffline {
+		t.Fatalf("expected reset endpoint to be marked offline, got %+v", endpoint)
+	}
+	endpoint.Status = domain.RunEndpointStatusOnline
+	if err := svc.store.RunEndpoints().Update(endpoint); err != nil {
+		t.Fatalf("restore endpoint for regeneration: %v", err)
+	}
 	oldDistribution, err := svc.store.RunDistributions().Get(distribution.ID)
 	if err != nil {
 		t.Fatalf("get old distribution: %v", err)