Merge branch 'main' of https://github.com/github/gh-aw

Author: pelikhan

.changeset/patch-max-continuations.md

@@ -33,8 +33,8 @@
     "ghcr.io/anthropics/devcontainer-features/claude-code:1.0": {},
     "ghcr.io/devcontainers/features/copilot-cli:latest": {},
     "ghcr.io/devcontainers/features/docker-in-docker:2": {},
-    "ghcr.io/devcontainers/features/github-cli:1": {},
     "ghcr.io/devcontainers/features/git-lfs:1": {},
+    "ghcr.io/devcontainers/features/github-cli:1": {},
     "ghcr.io/devcontainers/features/node:1": {
       "version": "24"
     }

.devcontainer/devcontainer.json

@@ -15,7 +15,9 @@ permissions:
   discussions: read
   actions: read
 name: Smoke Copilot
-engine: copilot
+engine:
+  id: copilot
+  max-continuations: 2
 imports:
   - shared/gh.md
   - shared/reporting.md

.github/workflows/smoke-copilot.lock.yml

@@ -13,38 +13,43 @@ import (
 
 func TestImportCache(t *testing.T) {
 	tempDir := t.TempDir()
-
-	// Create a new cache
 	cache := NewImportCache(tempDir)
-
-	// Test Set and Get
+	const (
+		owner = "testowner"
+		repo  = "testrepo"
+		path  = "workflows/test.md"
+		sha   = "abc123"
+	)
 	testContent := []byte("# Test Workflow\n\nTest content")
-	owner := "testowner"
-	repo := "testrepo"
-	path := "workflows/test.md"
-	sha := "abc123"
-
-	cachedPath, err := cache.Set(owner, repo, path, sha, testContent)
-	require.NoError(t, err, "Set should succeed for valid inputs")
-
-	// Verify file was created
-	require.FileExists(t, cachedPath, "cache file should be created at expected path")
-
-	// Verify content
-	content, err := os.ReadFile(cachedPath)
-	require.NoError(t, err, "reading cached file should succeed")
-	assert.Equal(t, string(testContent), string(content), "cached content should match original")
-
-	// Test Get
-	retrievedPath, found := cache.Get(owner, repo, path, sha)
-	assert.True(t, found, "cache entry should be found after Set")
-	assert.Equal(t, cachedPath, retrievedPath, "retrieved path from Get should match path returned by Set")
 
-	// Test that a new cache instance can find the file
-	cache2 := NewImportCache(tempDir)
-	retrievedPath2, found := cache2.Get(owner, repo, path, sha)
-	assert.True(t, found, "cache entry should be found from new cache instance")
-	assert.Equal(t, cachedPath, retrievedPath2, "path from new cache instance should match original cached path")
+	t.Run("Set creates file and returns path", func(t *testing.T) {
+		cachedPath, err := cache.Set(owner, repo, path, sha, testContent)
+		require.NoError(t, err, "Set should succeed for valid inputs")
+		require.FileExists(t, cachedPath, "cache file should be created at expected path")
+	})
+
+	t.Run("Get returns cached path after Set", func(t *testing.T) {
+		cachedPath, _ := cache.Set(owner, repo, path, sha, testContent)
+		retrievedPath, found := cache.Get(owner, repo, path, sha)
+		assert.True(t, found, "cache entry should be found after Set")
+		assert.Equal(t, cachedPath, retrievedPath, "retrieved path should match path returned by Set")
+	})
+
+	t.Run("Cached file content matches original", func(t *testing.T) {
+		cachedPath, err := cache.Set(owner, repo, path, sha, testContent)
+		require.NoError(t, err, "Set should succeed")
+		content, err := os.ReadFile(cachedPath)
+		require.NoError(t, err, "reading cached file should succeed")
+		assert.Equal(t, string(testContent), string(content), "cached content should match original")
+	})
+
+	t.Run("New cache instance finds existing entry", func(t *testing.T) {
+		cachedPath, _ := cache.Set(owner, repo, path, sha, testContent)
+		cache2 := NewImportCache(tempDir)
+		retrievedPath2, found := cache2.Get(owner, repo, path, sha)
+		assert.True(t, found, "cache entry should be found from new cache instance")
+		assert.Equal(t, cachedPath, retrievedPath2, "path from new instance should match original")
+	})
 }
 
 func TestImportCacheDirectory(t *testing.T) {
@@ -131,6 +136,26 @@ func TestSanitizePath(t *testing.T) {
 			input:    "a/./b/file.md",
 			expected: "a_b_file.md",
 		},
+		{
+			name:     "empty string",
+			input:    "",
+			expected: ".",
+		},
+		{
+			name:     "trailing slash",
+			input:    "a/b/",
+			expected: "a_b",
+		},
+		{
+			name:     "single dot component",
+			input:    "a/./b",
+			expected: "a_b",
+		},
+		{
+			name:     "leading slash becomes root-like",
+			input:    "/absolute/path",
+			expected: "_absolute_path",
+		},
 	}
 
 	for _, tt := range tests {
@@ -204,6 +229,33 @@ func TestValidatePathComponents(t *testing.T) {
 			shouldErr: true,
 			errMsg:    "absolute path",
 		},
+		{
+			name:      "empty repo",
+			owner:     "testowner",
+			repo:      "",
+			path:      "test.md",
+			sha:       "abc123",
+			shouldErr: true,
+			errMsg:    "empty component",
+		},
+		{
+			name:      "empty path",
+			owner:     "testowner",
+			repo:      "testrepo",
+			path:      "",
+			sha:       "abc123",
+			shouldErr: true,
+			errMsg:    "empty component",
+		},
+		{
+			name:      "path traversal embedded in sha",
+			owner:     "testowner",
+			repo:      "testrepo",
+			path:      "test.md",
+			sha:       "abc..def",
+			shouldErr: true,
+			errMsg:    "..",
+		},
 	}
 
 	for _, tt := range tests {
@@ -272,6 +324,15 @@ func TestImportCacheSet_Validation(t *testing.T) {
 			shouldErr: true,
 			errMsg:    "invalid path components",
 		},
+		{
+			name:      "valid inputs succeed",
+			owner:     "owner",
+			repo:      "repo",
+			path:      "workflows/test.md",
+			sha:       "abc123def456",
+			content:   []byte("# valid content"),
+			shouldErr: false,
+		},
 	}
 
 	cache := NewImportCache(tempDir)
@@ -287,3 +348,33 @@ func TestImportCacheSet_Validation(t *testing.T) {
 		})
 	}
 }
+
+func TestImportCacheSetIdempotent(t *testing.T) {
+	tempDir := t.TempDir()
+	cache := NewImportCache(tempDir)
+
+	firstContent := []byte("first content")
+	secondContent := []byte("second content")
+
+	path1, err := cache.Set("owner", "repo", "test.md", "sha1", firstContent)
+	require.NoError(t, err, "first Set should succeed")
+
+	path2, err := cache.Set("owner", "repo", "test.md", "sha1", secondContent)
+	require.NoError(t, err, "second Set with same key should succeed (overwrite)")
+	assert.Equal(t, path1, path2, "both Set calls should return the same cache path")
+
+	content, err := os.ReadFile(path2)
+	require.NoError(t, err, "reading overwritten file should succeed")
+	assert.Equal(t, string(secondContent), string(content), "file should contain second (latest) content")
+}
+
+func TestImportCacheGetDoesNotValidateComponents(t *testing.T) {
+	// Document that Get does not validate components (unlike Set).
+	// If validation is added in the future, this test should be updated.
+	tempDir := t.TempDir()
+	cache := NewImportCache(tempDir)
+
+	// Should return not-found (not panic or error), even with suspicious inputs.
+	_, found := cache.Get("../etc", "repo", "test.md", "sha")
+	assert.False(t, found, "Get with path traversal input should return not-found, not panic")
+}

.github/workflows/smoke-copilot.md

@@ -7413,6 +7413,10 @@
           "id": "copilot",
           "version": "beta"
         },
+        {
+          "id": "copilot",
+          "max-continuations": 5
+        },
         {
           "id": "claude",
           "concurrency": {
@@ -7458,6 +7462,11 @@
               ],
               "description": "Maximum number of chat iterations per run. Helps prevent runaway loops and control costs. Has sensible defaults and can typically be omitted. Note: Only supported by the claude engine."
             },
+            "max-continuations": {
+              "type": "integer",
+              "minimum": 1,
+              "description": "Maximum number of continuations for multi-run autopilot mode. Default is 1 (single run, no autopilot). Values greater than 1 enable --autopilot mode for the copilot engine with --max-autopilot-continues set to this value. Note: Only supported by the copilot engine."
+            },
             "concurrency": {
               "oneOf": [
                 {

docs/slides/github-agentic-workflows.pdf

@@ -12,6 +12,7 @@
 //
 //   - validateAgentFile() - Validates custom agent file exists
 //   - validateMaxTurnsSupport() - Validates max-turns feature support
+//   - validateMaxContinuationsSupport() - Validates max-continuations feature support
 //   - validateWebSearchSupport() - Validates web-search feature support (warning)
 //   - validateWorkflowRunBranches() - Validates workflow_run has branch restrictions
 //
@@ -122,6 +123,24 @@ func (c *Compiler) validateMaxTurnsSupport(frontmatter map[string]any, engine Co
 	return nil
 }
 
+// validateMaxContinuationsSupport validates that max-continuations is only used with engines that support this feature
+func (c *Compiler) validateMaxContinuationsSupport(frontmatter map[string]any, engine CodingAgentEngine) error {
+	// Check if max-continuations is specified in the engine config
+	_, engineConfig := c.ExtractEngineConfig(frontmatter)
+
+	if engineConfig == nil || engineConfig.MaxContinuations == 0 {
+		// No max-continuations specified, no validation needed
+		return nil
+	}
+
+	// max-continuations is specified, check if the engine supports it
+	if !engine.SupportsMaxContinuations() {
+		return fmt.Errorf("max-continuations not supported: engine '%s' does not support the max-continuations feature", engine.GetID())
+	}
+
+	return nil
+}
+
 // validateWebSearchSupport validates that web-search tool is only used with engines that support this feature
 func (c *Compiler) validateWebSearchSupport(tools map[string]any, engine CodingAgentEngine) {
 	// Check if web-search tool is requested

docs/slides/github-agentic-workflows.pptx

@@ -126,6 +126,10 @@ type CapabilityProvider interface {
 	// When true, plugins can be installed using the engine's plugin install command
 	SupportsPlugins() bool
 
+	// SupportsMaxContinuations returns true if this engine supports the max-continuations feature
+	// When true, max-continuations > 1 enables autopilot/multi-run mode for the engine
+	SupportsMaxContinuations() bool
+
 	// SupportsLLMGateway returns the LLM gateway port number for this engine
 	// Returns the port number (e.g., 10000) if the engine supports an LLM gateway
 	// Returns -1 if the engine does not support an LLM gateway
@@ -207,17 +211,18 @@ type CodingAgentEngine interface {
 
 // BaseEngine provides common functionality for agentic engines
 type BaseEngine struct {
-	id                     string
-	displayName            string
-	description            string
-	experimental           bool
-	supportsToolsAllowlist bool
-	supportsMaxTurns       bool
-	supportsWebFetch       bool
-	supportsWebSearch      bool
-	supportsFirewall       bool
-	supportsPlugins        bool
-	supportsLLMGateway     bool
+	id                       string
+	displayName              string
+	description              string
+	experimental             bool
+	supportsToolsAllowlist   bool
+	supportsMaxTurns         bool
+	supportsMaxContinuations bool
+	supportsWebFetch         bool
+	supportsWebSearch        bool
+	supportsFirewall         bool
+	supportsPlugins          bool
+	supportsLLMGateway       bool
 }
 
 func (e *BaseEngine) GetID() string {
@@ -260,6 +265,10 @@ func (e *BaseEngine) SupportsPlugins() bool {
 	return e.supportsPlugins
 }
 
+func (e *BaseEngine) SupportsMaxContinuations() bool {
+	return e.supportsMaxContinuations
+}
+
 func (e *BaseEngine) SupportsLLMGateway() int {
 	// Engines that support LLM gateway must override this method
 	// to return their specific port number (e.g., 10000, 10001, 10002)