kandev/apps/backend/internal/agentctl/server/acp/client_test.go

package acp

import (
	"context"
	"path/filepath"
	"reflect"
	"testing"

	"github.com/coder/acp-go-sdk"
	"github.com/kandev/kandev/internal/agentctl/types"
)

func TestResolvePath(t *testing.T) {
	client := NewClient(WithWorkspaceRoot("/workspace/project"))

	tests := []struct {
		name      string
		input     string
		expected  string
		expectErr bool
	}{
		{
			name:     "absolute path within workspace",
			input:    "/workspace/project/src/main.go",
			expected: "/workspace/project/src/main.go",
		},
		{
			name:     "relative path resolves within workspace",
			input:    "src/main.go",
			expected: filepath.Join("/workspace/project", "src/main.go"),
		},
		{
			name:     "workspace root itself is allowed",
			input:    "/workspace/project",
			expected: "/workspace/project",
		},
		{
			name:     "dot path resolves to workspace root",
			input:    ".",
			expected: "/workspace/project",
		},
		{
			name:      "path traversal with relative path is rejected",
			input:     "../../etc/passwd",
			expectErr: true,
		},
		{
			name:      "path traversal with dot-dot in middle is rejected",
			input:     "src/../../etc/passwd",
			expectErr: true,
		},
		{
			name:      "absolute path outside workspace is rejected",
			input:     "/etc/passwd",
			expectErr: true,
		},
		{
			name:      "absolute path with parent traversal is rejected",
			input:     "/workspace/project/../../../etc/passwd",
			expectErr: true,
		},
		{
			name:     "nested relative path within workspace",
			input:    "src/pkg/handler.go",
			expected: filepath.Join("/workspace/project", "src/pkg/handler.go"),
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := client.resolvePath(tt.input)
			if tt.expectErr {
				if err == nil {
					t.Errorf("resolvePath(%q) expected error, got path %q", tt.input, got)
				}
				return
			}
			if err != nil {
				t.Errorf("resolvePath(%q) unexpected error: %v", tt.input, err)
				return
			}
			if got != tt.expected {
				t.Errorf("resolvePath(%q) = %q, want %q", tt.input, got, tt.expected)
			}
		})
	}
}

func TestForwardPermissionRequestTitleDerivation(t *testing.T) {
	str := func(s string) *string { return &s }
	kind := func(k acp.ToolKind) *acp.ToolKind { return &k }
	allowOpt := acp.PermissionOption{OptionId: "allow", Name: "Allow", Kind: acp.PermissionOptionKindAllowOnce}

	tests := []struct {
		name           string
		toolCall       acp.ToolCallUpdate
		wantTitle      string
		wantActionType string
		wantDescInDtl  bool
		wantRawInput   map[string]any
	}{
		{
			name: "title present, kind other -> human title wins",
			toolCall: acp.ToolCallUpdate{
				ToolCallId: "tc-1",
				Title:      str("Run bash command 'ls -la'"),
				Kind:       kind(acp.ToolKindOther),
			},
			wantTitle:      "Run bash command 'ls -la'",
			wantActionType: "other",
			wantDescInDtl:  true,
		},
		{
			name: "title present, kind execute -> human title still wins",
			toolCall: acp.ToolCallUpdate{
				ToolCallId: "tc-2",
				Title:      str("Run bash command 'rm -rf'"),
				Kind:       kind(acp.ToolKindExecute),
			},
			wantTitle:      "Run bash command 'rm -rf'",
			wantActionType: "execute",
			wantDescInDtl:  true,
		},
		{
			name: "only kind -> kind is the title, no description forwarded",
			toolCall: acp.ToolCallUpdate{
				ToolCallId: "tc-3",
				Kind:       kind(acp.ToolKindEdit),
			},
			wantTitle:      "edit",
			wantActionType: "edit",
			wantDescInDtl:  false,
		},
		{
			name: "only title, no kind",
			toolCall: acp.ToolCallUpdate{
				ToolCallId: "tc-4",
				Title:      str("Reading configuration file"),
			},
			wantTitle:      "Reading configuration file",
			wantActionType: "",
			wantDescInDtl:  true,
		},
		{
			name: "neither title nor kind -> both empty",
			toolCall: acp.ToolCallUpdate{
				ToolCallId: "tc-5",
			},
			wantTitle:      "",
			wantActionType: "",
			wantDescInDtl:  false,
		},
		{
			name: "whitespace-only title falls back to kind",
			toolCall: acp.ToolCallUpdate{
				ToolCallId: "tc-ws",
				Title:      str("   "),
				Kind:       kind(acp.ToolKindExecute),
			},
			wantTitle:      "execute",
			wantActionType: "execute",
			wantDescInDtl:  false,
		},
		{
			name: "raw_input forwarded into ActionDetails",
			toolCall: acp.ToolCallUpdate{
				ToolCallId: "tc-6",
				Title:      str("Run bash"),
				Kind:       kind(acp.ToolKindExecute),
				RawInput:   map[string]any{"command": "ls -la", "cwd": "/tmp"},
			},
			wantTitle:      "Run bash",
			wantActionType: "execute",
			wantDescInDtl:  true,
			wantRawInput:   map[string]any{"command": "ls -la", "cwd": "/tmp"},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			c := NewClient()
			var captured *types.PermissionRequest
			handler := func(_ context.Context, req *types.PermissionRequest) (*types.PermissionResponse, error) {
				captured = req
				return &types.PermissionResponse{OptionID: "allow"}, nil
			}
			req := acp.RequestPermissionRequest{
				SessionId: "sess",
				ToolCall:  tt.toolCall,
				Options:   []acp.PermissionOption{allowOpt},
			}
			if _, err := c.forwardPermissionRequest(context.Background(), handler, req); err != nil {
				t.Fatalf("forwardPermissionRequest returned error: %v", err)
			}
			if captured == nil {
				t.Fatal("handler not invoked")
			}
			if captured.Title != tt.wantTitle {
				t.Errorf("Title = %q, want %q", captured.Title, tt.wantTitle)
			}
			if captured.ActionType != tt.wantActionType {
				t.Errorf("ActionType = %q, want %q", captured.ActionType, tt.wantActionType)
			}
			_, hasDesc := captured.ActionDetails["description"]
			if hasDesc != tt.wantDescInDtl {
				t.Errorf("ActionDetails.description present = %v, want %v (details=%v)", hasDesc, tt.wantDescInDtl, captured.ActionDetails)
			}
			if tt.wantRawInput != nil {
				gotRaw, ok := captured.ActionDetails["raw_input"].(map[string]any)
				if !ok {
					t.Fatalf("ActionDetails.raw_input missing or wrong type: %#v", captured.ActionDetails["raw_input"])
				}
				if !reflect.DeepEqual(gotRaw, tt.wantRawInput) {
					t.Errorf("ActionDetails.raw_input = %v, want %v", gotRaw, tt.wantRawInput)
				}
			}
		})
	}
}