PR5: Modern sandbox execution (single-owner lifecycle, policy-at-create)

cmd/apply.go

@@ -56,7 +56,8 @@ then deploy a sandbox. Use --dry-run to validate without deploying, or
  agentCfg.Entrypoint = entrypoint
  }
  if task != "" && !attach {
- // Headless task: set TTY=false so BuildRunSh generates --print
+ // Headless task: set TTY=false so the agent adapter dispatches with
+ // --print (claude/codex) or run (opencode) instead of interactive -p.
  f := false
  agentCfg.TTY = &f
  }

cmd/executor.go

@@ -15,8 +15,10 @@ import (
 	"github.com/stackrox/harness-openshell/internal/gateway"
 	"github.com/stackrox/harness-openshell/internal/k8s"
 	"github.com/stackrox/harness-openshell/internal/openshell"
+	"github.com/stackrox/harness-openshell/internal/payload"
 	"github.com/stackrox/harness-openshell/internal/plan"
 	"github.com/stackrox/harness-openshell/internal/reconcile"
+	"github.com/stackrox/harness-openshell/internal/run"
 	"github.com/stackrox/harness-openshell/internal/status"
 )
 
@@ -123,7 +125,7 @@ func upLocal(opts upLocalOpts) error {
 	// Resolve payload entries into upload pairs. Inline content payloads are
 	// written to temp files that are uploaded individually by their own
 	// sandbox_path, so their source paths must survive until SandboxCreate.
-	// They MUST NOT live inside payloadDir: createSandbox renames payloadDir
+	// They MUST NOT live inside payloadDir: stagePayloadUpload renames payloadDir
 	// into a staging directory, which would invalidate any path pointing inside
 	// it and fail every upload with "local path does not exist" (issue #84).
 	var extraUploads []gateway.Upload
@@ -148,53 +150,65 @@ func upLocal(opts upLocalOpts) error {
 	}
 
 	status.Header("Sandbox")
+
+	// Command: the agent adapter owns entrypoint + task dispatch (replaces the
+	// generated run.sh). Headless with no task starts the sandbox without an agent.
+	taskPath := ""
+	if agentCfg.Task != "" {
+ taskPath = agent.SandboxTaskPath
+	}
 	var sandboxCmd []string
 	if noTTY && agentCfg.Task == "" {
  sandboxCmd = []string{"true"}
 	} else {
- sandboxCmd = []string{"bash", "/sandbox/.config/openshell/run.sh"}
-	}
-
-	err = createSandbox(sandboxOpts{
- harnessDir: opts.harnessDir,
- gw: gw,
- name: sandboxName,
- image: sandboxImage,
- providers: registered,
- noTTY: noTTY,
- retrySleep: opts.retrySleep,
- sandboxCmd: sandboxCmd,
- payloadDir: payloadDir,
- uploads: extraUploads,
- env: agentCfg.BuildEnvMap(),
-	})
+ cmd, cmdErr := agent.AdapterFor(agentCfg.EffectiveEntrypoint()).Command(agentCfg, taskPath)
+ if cmdErr != nil {
+ return fmt.Errorf("building sandbox command: %w", cmdErr)
+ }
+ sandboxCmd = cmd
+	}
+
+	// Stage the rendered payload for upload (--upload lands it at
+	// /sandbox/.config/openshell/*).
+	uploadDir, cleanupUpload, err := stagePayloadUpload(payloadDir)
 	if err != nil {
  return err
 	}
+	defer cleanupUpload()
 
-	// Apply custom policy after sandbox creation (kind: policy in harness YAML).
-	// /etc/openshell/policy.yaml is read-only in the image, so policy changes
-	// must go through the openshell CLI which hot-reloads the policy.
+	uploads := []gateway.Upload{{Src: uploadDir, Dst: "/sandbox/.config"}}
+	uploads = append(uploads, extraUploads...)
+
+	// Stage the effective policy and apply it AT CREATE via --policy.
+	// /etc/openshell/policy.yaml is read-only in the image; policy-at-create is
+	// authoritative (the old post-create hot-reload could be silently dropped).
+	var policyPath string
 	if opts.harness != nil && opts.harness.Policy != nil {
- policyFile, writeErr := os.CreateTemp("", "harness-policy-*.yaml")
- if writeErr != nil {
- return fmt.Errorf("creating policy temp file: %w", writeErr)
- }
- defer os.Remove(policyFile.Name())
- if _, writeErr := policyFile.Write(opts.harness.Policy); writeErr != nil {
- policyFile.Close()
- return fmt.Errorf("writing policy: %w", writeErr)
+ policyDir, mkErr := os.MkdirTemp("", "harness-policy-")
+ if mkErr != nil {
+ return fmt.Errorf("creating policy dir: %w", mkErr)
  }
- policyFile.Close()
-
- status.Info("Applying custom policy...")
- if err := gw.PolicySet(sandboxName, policyFile.Name()); err != nil {
- return fmt.Errorf("applying policy: %w", err)
+ defer os.RemoveAll(policyDir)
+ p, wErr := payload.WriteEffectivePolicy(policyDir, opts.harness.Policy)
+ if wErr != nil {
+ return fmt.Errorf("writing policy: %w", wErr)
  }
- status.OK("Policy applied")
-	}
-
-	return nil
+ policyPath = p
+	}
+
+	return run.RunSandbox(context.Background(), gw, run.SandboxRunRequest{
+ Name: sandboxName,
+ Gateway: gw.ActiveGateway(),
+ Image: resolveSandboxImagePath(sandboxImage, opts.harnessDir),
+ Providers: registered,
+ Env: agentCfg.BuildEnvMap(),
+ Command: sandboxCmd,
+ Uploads: uploads,
+ TTY: !noTTY,
+ Keep: true,
+ PolicyPath: policyPath,
+ RetrySleep: opts.retrySleep,
+	})
 }
 
 // cloneRepo clones or updates a cached git repository and returns an Upload

cmd/helpers_test.go

@@ -108,4 +108,3 @@ env:
 `), 0o644)
 	return dir
 }
-func (m *mockGW) PolicySet(string, string) error { return nil }

cmd/sandbox.go

@@ -4,87 +4,34 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
-	"time"
-
-	"github.com/stackrox/harness-openshell/internal/gateway"
-	"github.com/stackrox/harness-openshell/internal/status"
 )
 
-// sandboxOpts holds the parameters that vary between callers of
-// createSandbox (upLocal vs create). Everything else is derived
-// from the agent config passed alongside.
-type sandboxOpts struct {
-	harnessDir string
-	gw gateway.Gateway
-	name string // sandbox name
-	image string // sandbox image ref or relative Dockerfile dir
-	providers []string // registered providers to attach
-	noTTY bool // true → TTY=false for the sandbox
-	retrySleep time.Duration // pause between retry attempts
-	sandboxCmd []string // command to run inside the sandbox
-	payloadDir string // pre-rendered payload dir to upload
-	uploads []gateway.Upload // additional uploads (payloads)
-	env map[string]string // env vars injected via --env on sandbox create
-	onSuccess func(name string) // called after successful creation (optional)
-}
-
-// createSandbox resolves the image path, stages the payload directory,
-// creates the sandbox with up to 5 retries, and cleans up on failure.
-// Both upLocal and create delegate to this function after preparing
-// their caller-specific sandboxOpts.
-func createSandbox(opts sandboxOpts) error {
-	// Relative Dockerfile dirs are resolved against harnessDir.
-	image := opts.image
-	if image != "" && !filepath.IsAbs(image) {
- candidate := filepath.Join(opts.harnessDir, image)
- if info, err := os.Stat(candidate); err == nil && info.IsDir() {
- image = candidate
- }
+// resolveSandboxImagePath resolves a relative Dockerfile directory against
+// harnessDir. An image ref (or an already-absolute path) is returned unchanged.
+func resolveSandboxImagePath(image, harnessDir string) string {
+	if image == "" || filepath.IsAbs(image) {
+ return image
 	}
+	candidate := filepath.Join(harnessDir, image)
+	if info, err := os.Stat(candidate); err == nil && info.IsDir() {
+ return candidate
+	}
+	return image
+}
 
-	// Stage upload directory. openshell --upload copies the source directory
-	// BY NAME into the destination, so we always create a subdirectory called
-	// "openshell" and upload to /sandbox/.config → /sandbox/.config/openshell/*.
+// stagePayloadUpload moves the rendered payload dir into a staging directory
+// named "openshell" so that `openshell --upload` copies it BY NAME into
+// /sandbox/.config → /sandbox/.config/openshell/*. It returns the staged upload
+// source dir and a cleanup func that removes the staging parent.
+func stagePayloadUpload(payloadDir string) (uploadDir string, cleanup func(), err error) {
 	tmpParent, err := os.MkdirTemp("", "harness-")
 	if err != nil {
- return fmt.Errorf("creating staging dir: %w", err)
+ return "", nil, fmt.Errorf("creating staging dir: %w", err)
 	}
-	defer os.RemoveAll(tmpParent)
-	uploadDir := filepath.Join(tmpParent, "openshell")
-
-	if err := os.Rename(opts.payloadDir, uploadDir); err != nil {
- return fmt.Errorf("staging payload: %w", err)
-	}
-
-	const maxRetries = 5
-	for attempt := 1; attempt <= maxRetries; attempt++ {
- uploads := []gateway.Upload{{Src: uploadDir, Dst: "/sandbox/.config"}}
- uploads = append(uploads, opts.uploads...)
-
- err := opts.gw.SandboxCreate(gateway.SandboxCreateOpts{
- Name: opts.name,
- From: image,
- Providers: opts.providers,
- TTY: !opts.noTTY,
- Keep: true,
- Uploads: uploads,
- Command: opts.sandboxCmd,
- Env: opts.env,
- })
- if err == nil {
- if opts.onSuccess != nil {
- opts.onSuccess(opts.name)
- }
- return nil
- }
-
- status.Warnf("attempt %d: %v, retrying in %s", attempt, err, opts.retrySleep)
- opts.gw.SandboxDelete(opts.name) // best-effort cleanup
-
- if attempt == maxRetries {
- return fmt.Errorf("sandbox create failed after 5 attempts: %w", err)
- }
- time.Sleep(opts.retrySleep)
+	uploadDir = filepath.Join(tmpParent, "openshell")
+	if err := os.Rename(payloadDir, uploadDir); err != nil {
+ os.RemoveAll(tmpParent)
+ return "", nil, fmt.Errorf("staging payload: %w", err)
 	}
-	return nil // unreachable but required by compiler
+	return uploadDir, func() { os.RemoveAll(tmpParent) }, nil
 }

cmd/status_cmd_test.go

@@ -50,4 +50,3 @@ func TestRunStatus_NoGateway(t *testing.T) {
  t.Fatalf("runStatus: %v", err)
 	}
 }
-func (m *statusMockGW) PolicySet(string, string) error { return nil }