feat: babysit support (#747)

* babysit support

* Update pkg/agentrun-harness/tool/codex/codex.go

Co-authored-by: greptile-apps[bot] <165735046+greptile-apps[bot]@users.noreply.github.com>

* check context

* fix codex

* add gemini

* add opencode

* fix gemini

* bump gemini

* fix gemini Dockerfile

* add gitAccessTokenEnv

* add gitAccessTokenEnv

* linter

---------

Co-authored-by: greptile-apps[bot] <165735046+greptile-apps[bot]@users.noreply.github.com>

Author: zreigz

.github/workflows/publish-agent-harness.yaml

@@ -26,7 +26,7 @@ jobs:
     env:
       NODE_VERSION: 24
       CLAUDE_VERSION: 2.1.72
-      GEMINI_VERSION: 0.6.1
+      GEMINI_VERSION: 0.36.0
       OPENCODE_VERSION: 1.2.24
       CODEX_VERSION: 0.104.0
     outputs:
@@ -172,7 +172,7 @@ jobs:
           - name: claude
             version: 2.1.72
           - name: gemini
-            version: 0.6.1
+            version: 0.36.0
           - name: opencode
             version: 1.2.24
           - name: codex

dockerfiles/agent-harness/gemini.Dockerfile

@@ -1,36 +1,53 @@
 ARG NODE_IMAGE_TAG=24
 ARG NODE_IMAGE=node:${NODE_IMAGE_TAG}-slim
-ARG AGENT_VERSION=latest
+ARG AGENT_VERSION=0.36.0
 
 ARG AGENT_HARNESS_BASE_IMAGE_TAG=latest
 ARG AGENT_HARNESS_BASE_IMAGE_REPO=ghcr.io/pluralsh/agent-harness-base
 ARG AGENT_HARNESS_BASE_IMAGE=$AGENT_HARNESS_BASE_IMAGE_REPO:$AGENT_HARNESS_BASE_IMAGE_TAG
 
-# Stage 1: Install Gemini CLI from npm in Chainguard Node image
+# Stage 1: Install Gemini CLI from npm in Node image
 FROM $NODE_IMAGE AS node
 
-# Switch to root temporarily to install global packages
+# Re-declare ARGs after FROM so they are available in this stage
+ARG AGENT_VERSION
+
 USER root
 
 # Install Gemini CLI globally using npm
-RUN yarn global add @google/gemini-cli@$AGENT_VERSION
+RUN npm install -g @google/gemini-cli@$AGENT_VERSION
+
+# Copy to a fixed, predictable path
+RUN cp -r $(npm root -g)/@google/gemini-cli /opt/gemini-cli
+
+# Resolve the actual bin entry point from package.json and save it
+RUN node -e "\
+  const pkg = require('/opt/gemini-cli/package.json'); \
+  const bin = pkg.bin; \
+  const rel = typeof bin === 'string' ? bin : (bin.gemini || bin['gemini-cli'] || Object.values(bin)[0]); \
+  const abs = require('path').resolve('/opt/gemini-cli', rel); \
+  process.stdout.write(abs);" > /opt/gemini-entry.txt && \
+  echo "Gemini entry point: $(cat /opt/gemini-entry.txt)"
 
-# Verify installation
-RUN gemini --version
+# Verify
+RUN node $(cat /opt/gemini-entry.txt) --version
 
 # Stage 2: Copy Gemini CLI into agent-harness base
 FROM $AGENT_HARNESS_BASE_IMAGE AS final
 
-# Copy the Gemini CLI from the Node.js image
-COPY --from=node /usr/local/share/.config/yarn/global /usr/local/share/.config/yarn/global
+# Copy the Gemini CLI module and resolved entry point from the Node.js image
+COPY --from=node /opt/gemini-cli /opt/gemini-cli
+COPY --from=node /opt/gemini-entry.txt /opt/gemini-entry.txt
 
 # Copy Node.js runtime (needed to run the CLI)
 COPY --from=node /usr/local/bin/node /usr/local/bin/node
 
-# Ensure proper ownership for nonroot user
+# Create wrapper script using the resolved entry point and set ownership
 USER root
-RUN ln -s /usr/local/share/.config/yarn/global/node_modules/@google/gemini-cli/dist/index.js /usr/local/bin/gemini
-RUN chown -R 65532:65532 /usr/local/share/.config/yarn/global /usr/local/bin/gemini /usr/local/bin/node
+RUN ENTRY=$(cat /opt/gemini-entry.txt) && \
+    printf '#!/bin/sh\nexec /usr/local/bin/node %s "$@"\n' "$ENTRY" > /usr/local/bin/gemini && \
+    chmod +x /usr/local/bin/gemini && \
+    chown -R 65532:65532 /opt/gemini-cli /usr/local/bin/gemini /usr/local/bin/node
 
 # Switch back to nonroot user
 USER 65532:65532

pkg/agentrun-harness/tool/codex/codex.go

@@ -63,6 +63,11 @@ func (in *Codex) Run(ctx context.Context, options ...exec.Option) {
 	go in.start(ctx, options...)
 }
 
+func (in *Codex) ConfigureBabysitRun() error {
+	klog.Info("configuring codex babysit run")
+	return in.ConfigureSystemPromptForBabysitRun(console.AgentRuntimeTypeCodex)
+}
+
 func (in *Codex) Configure(consoleURL, consoleToken, deployToken string) error {
 	if err := in.ConfigureSystemPrompt(console.AgentRuntimeTypeCodex); err != nil {
 		return err
@@ -153,7 +158,7 @@ func (in *Codex) Configure(consoleURL, consoleToken, deployToken string) error {
 			Type:         "stdio",
 			Command:      "/usr/local/bin/mcpserver",
 			TrustPolicy:  "always",
-			EnabledTools: []string{"agentPullRequest", "createBranch", "fetchAgentRunTodos", "updateAgentRunTodos"},
+			EnabledTools: []string{"agentPullRequest", "createBranch", "fetchAgentRunTodos", "updateAgentRunTodos", "getPRState", "getCILogs", "reactToComment", "createCommit"},
 			Env:          mcpBaseEnv,
 		}}
 	default:
@@ -201,6 +206,57 @@ func (in *Codex) OnMessage(f func(message *console.AgentMessageAttributes)) {
 	in.onMessage = f
 }
 
+func (in *Codex) BabysitRun(ctx context.Context, bCtx *v1.BabysitContext) bool {
+	klog.V(log.LogLevelInfo).InfoS("starting codex babysit run", "agent_run_id", in.Config.Run.ID)
+	if bCtx == nil {
+		return false
+	}
+
+	agent := "autonomous"
+	args := []string{"exec", "--profile", agent, "--skip-git-repo-check", "--json", bCtx.Prompt}
+
+	in.executable = exec.NewExecutable(
+		"codex",
+		exec.WithArgs(args),
+		exec.WithDir(in.Config.WorkDir),
+		exec.WithEnv([]string{fmt.Sprintf("PLRL_CONSOLE_TOKEN=%s", in.consoleToken), fmt.Sprintf("CODEX_HOME=%s", path.Join(in.Config.WorkDir, ".codex"))}),
+		exec.WithTimeout(in.Config.Run.Runtime.Config.Codex.Timeout),
+	)
+
+	klog.V(log.LogLevelInfo).InfoS("codex executable configured", "timeout", in.Config.Run.Runtime.Config.Codex.Timeout)
+
+	// Send the initial prompt as a message too
+	if in.onMessage != nil {
+		in.onMessage(&console.AgentMessageAttributes{Message: bCtx.Prompt, Role: console.AiRoleUser})
+	}
+
+	err := in.executable.RunStream(ctx, func(line []byte) {
+		event := &StreamEvent{}
+		if err := json.Unmarshal(line, event); err != nil {
+			klog.V(log.LogLevelExtended).InfoS("failed to unmarshal codex stream event", "line", string(line))
+			return
+		}
+
+		if event.Type == "thread.started" && event.ThreadID != "" {
+			in.threadID = event.ThreadID
+			klog.V(log.LogLevelDebug).InfoS("codex thread started", "thread_id", in.threadID)
+		}
+
+		msg := mapCodexStreamEventToAgentMessage(event, in.threadID)
+		if in.onMessage != nil && msg != nil {
+			in.onMessage(msg)
+		}
+	})
+	if err != nil {
+		klog.ErrorS(err, "codex execution failed")
+		in.Config.ErrorChan <- err
+		return false
+	}
+
+	klog.V(log.LogLevelExtended).InfoS("codex babysit run finished")
+	return false
+}
+
 func (in *Codex) start(ctx context.Context, options ...exec.Option) {
 	// In proxy mode the plural provider handles auth via PLRL_CONSOLE_TOKEN;
 	// codex login is only needed for direct OpenAI usage.

pkg/agentrun-harness/tool/gemini/gemini.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"os"
 	"path"
 	"strings"
 
@@ -34,12 +35,73 @@ type Gemini struct {
 	model Model
 }
 
+func (in *Gemini) BabysitRun(ctx context.Context, bCtx *v1.BabysitContext) bool {
+	if bCtx == nil {
+		return false
+	}
+
+	env := []string{fmt.Sprintf("GEMINI_API_KEY=%s", in.apiKey), fmt.Sprintf("GEMINI_CLI_TRUST_WORKSPACE=%s", "true")}
+	if in.Config.Run.Runtime.Config.Gemini.Endpoint != nil {
+		env = append(env, fmt.Sprintf("GEMINI_API_BASE_URL=%s", *in.Config.Run.Runtime.Config.Gemini.Endpoint))
+	}
+
+	in.executable = exec.NewExecutable(
+		"gemini",
+		exec.WithArgs(in.args(bCtx.Prompt)),
+		exec.WithDir(in.Config.WorkDir),
+		exec.WithEnv(env),
+		exec.WithTimeout(in.Config.Run.Runtime.Config.Gemini.Timeout),
+	)
+
+	klog.V(log.LogLevelInfo).InfoS("Gemini executable configured", "timeout", in.Config.Run.Runtime.Config.Gemini.Timeout)
+
+	// Send the initial prompt as a message too
+	if in.onMessage != nil {
+		in.onMessage(&console.AgentMessageAttributes{Message: bCtx.Prompt, Role: console.AiRoleUser})
+	}
+
+	err := in.executable.RunStream(ctx, func(line []byte) {
+		klog.V(log.LogLevelTrace).InfoS("Gemini stream event", "line", string(line))
+
+		// This is here to prevent unavoidable log lines being reported as errors.
+		// TODO: Remove once https://github.com/google-gemini/gemini-cli/issues/15053 is fixed.
+		trimmed := strings.TrimSpace(string(line))
+		if !strings.HasPrefix(trimmed, "{") {
+			klog.V(log.LogLevelDebug).InfoS("ignoring non-json Gemini stream line", "trimmed", trimmed)
+			return
+		}
+
+		event := &events.EventBase{}
+		if err := json.Unmarshal(line, event); err != nil {
+			klog.ErrorS(err, "failed to unmarshal Gemini stream event", "line", line)
+			in.Config.ErrorChan <- err
+			return
+		}
+
+		if err := event.OnMessage(line, in.onMessage); err != nil {
+			klog.ErrorS(err, "failed to process Gemini stream event", "line", string(line))
+			in.Config.ErrorChan <- err
+		}
+	})
+	if err != nil {
+		klog.ErrorS(err, "Gemini execution failed")
+		in.Config.ErrorChan <- err
+		return false
+	}
+
+	return false
+}
+
+func (in *Gemini) ConfigureBabysitRun() error {
+	return in.ConfigureSystemPromptForBabysitRun(console.AgentRuntimeTypeGemini)
+}
+
 func (in *Gemini) Run(ctx context.Context, options ...exec.Option) {
 	go in.start(ctx, options...)
 }
 
 func (in *Gemini) start(ctx context.Context, options ...exec.Option) {
-	env := []string{fmt.Sprintf("GEMINI_API_KEY=%s", in.apiKey)}
+	env := []string{fmt.Sprintf("GEMINI_API_KEY=%s", in.apiKey), fmt.Sprintf("GEMINI_CLI_TRUST_WORKSPACE=%s", "true")}
 	if in.Config.Run.Runtime.Config.Gemini.Endpoint != nil {
 		env = append(env, fmt.Sprintf("GEMINI_API_BASE_URL=%s", *in.Config.Run.Runtime.Config.Gemini.Endpoint))
 	}
@@ -48,7 +110,7 @@ func (in *Gemini) start(ctx context.Context, options ...exec.Option) {
 		"gemini",
 		append(
 			options,
-			exec.WithArgs(in.args()),
+			exec.WithArgs(in.args("")),
 			exec.WithDir(in.Config.WorkDir),
 			exec.WithEnv(env),
 			exec.WithTimeout(in.Config.Run.Runtime.Config.Gemini.Timeout),
@@ -94,17 +156,20 @@ func (in *Gemini) start(ctx context.Context, options ...exec.Option) {
 	// FinishedChan is closed by the controller after the babysit loop exits.
 }
 
-func (in *Gemini) args() []string {
+func (in *Gemini) args(prompt string) []string {
+	if len(prompt) > 0 {
+		in.Config.Run.Prompt = prompt
+	}
 	if in.Config.Run.Mode == console.AgentRunModeWrite {
 		return []string{
 			"--approval-mode", "yolo",
-			"--output-format", "stream-json",
+			"--output-format", "stream-json", "--prompt",
 			in.Config.Run.Prompt,
 		}
 	}
 
 	return []string{
-		"--output-format", "stream-json",
+		"--output-format", "stream-json", "--prompt",
 		in.Config.Run.Prompt,
 	}
 }
@@ -124,6 +189,7 @@ func (in *Gemini) Configure(consoleURL, consoleToken, deployToken string) error
 		InactivityTimeout: int64(in.Config.Run.Runtime.Config.Gemini.InactivityTimeout.Seconds()),
 		Model:             in.model,
 		ExaMcpConfigs:     in.Config.Run.Runtime.ExaMcpConfigs,
+		GitAccessToken:    os.Getenv("GIT_ACCESS_TOKEN"),
 	}
 
 	_, content, err := settings(input)

pkg/agentrun-harness/tool/gemini/settings.go

@@ -24,6 +24,7 @@ type ConfigTemplateInput struct {
 	AgentRunMode      console.AgentRunMode
 	InactivityTimeout int64
 	ExaMcpConfigs     []agentrunv1.ExaMcpServerConfig
+	GitAccessToken    string
 }
 
 func settings(input *ConfigTemplateInput) (fileName, content string, err error) {

pkg/agentrun-harness/tool/gemini/settings_test.go

@@ -162,6 +162,61 @@ func TestSettingsTemplate_GenerateAndVerifyContents(t *testing.T) {
 	})
 }
 
+func TestSettingsTemplate_GitAccessToken(t *testing.T) {
+	baseInput := &ConfigTemplateInput{
+		Model:         ModelGemini25Pro,
+		RepositoryDir: "/repo",
+		ConsoleURL:    "https://console.test",
+		ConsoleToken:  "token",
+		DeployToken:   "deploy-token",
+		AgentRunID:    "run-123",
+		AgentRunMode:  console.AgentRunModeWrite,
+	}
+
+	getGitAccessToken := func(t *testing.T, content string) string {
+		t.Helper()
+		var out map[string]any
+		if err := json.Unmarshal([]byte(content), &out); err != nil {
+			t.Fatalf("generated content is not valid JSON: %v\n%s", err, content)
+		}
+		mcpServers := out["mcpServers"].(map[string]any)
+		plural := mcpServers["plural"].(map[string]any)
+		env := plural["env"].(map[string]any)
+		token, _ := env["GIT_ACCESS_TOKEN"].(string)
+		return token
+	}
+
+	t.Run("empty GitAccessToken renders empty string in env", func(t *testing.T) {
+		input := *baseInput
+		input.GitAccessToken = ""
+
+		_, content, err := settings(&input)
+		if err != nil {
+			t.Fatalf("settings() failed: %v", err)
+		}
+
+		token := getGitAccessToken(t, content)
+		if token != "" {
+			t.Errorf("expected empty GIT_ACCESS_TOKEN, got %q", token)
+		}
+	})
+
+	t.Run("non-empty GitAccessToken is rendered in env", func(t *testing.T) {
+		input := *baseInput
+		input.GitAccessToken = "ghp_mytoken123"
+
+		_, content, err := settings(&input)
+		if err != nil {
+			t.Fatalf("settings() failed: %v", err)
+		}
+
+		token := getGitAccessToken(t, content)
+		if token != "ghp_mytoken123" {
+			t.Errorf("expected GIT_ACCESS_TOKEN=ghp_mytoken123, got %q", token)
+		}
+	})
+}
+
 func TestSettingsTemplate_ExaMcpServers(t *testing.T) {
 	baseInput := &ConfigTemplateInput{
 		Model:         ModelGemini25Pro,

pkg/agentrun-harness/tool/gemini/templates/settings.json.gotmpl

@@ -50,6 +50,7 @@
         "PLRL_CONSOLE_TOKEN": "{{ .ConsoleToken }}",
         "PLRL_CONSOLE_URL": "{{ .ConsoleURL }}",
         "PLRL_AGENT_RUN_ID": "{{ .AgentRunID }}",
+        "GIT_ACCESS_TOKEN": "{{ .GitAccessToken }}",
         {{ if eq .AgentRunMode "WRITE" }}
         "PLRL_EXCLUDE_TOOLS": "updateAgentRunAnalysis"
         {{ else }}