client func() (*http.Client, error)

githubAPI string

githubServer string

retryBackoff time.Duration

apiURL := os.Getenv("GITHUB_API_URL")

if apiURL == "" {

cfg, err := f.Config()

if err != nil {

// fallback to the default api endpoint

apiURL = defaultAPIURL

} else {

host, _ := cfg.Authentication().DefaultHost()

apiURL = ghinstance.RESTPrefix(host)

}

}

serverURL := os.Getenv("GITHUB_SERVER_URL")

if serverURL == "" {

cfg, err := f.Config()

if err != nil {

// fallback to the default server endpoint

serverURL = defaultServerURL

} else {

host, _ := cfg.Authentication().DefaultHost()

serverURL = ghinstance.HostPrefix(host)

}

}

return &API{

client: f.HttpClient,

githubAPI: strings.TrimSuffix(apiURL, "/"),

githubServer: strings.TrimSuffix(serverURL, "/"),

retryBackoff: 100 * time.Millisecond,

}

req, err := http.NewRequest(http.MethodGet, a.githubAPI+"/user", nil)

if err != nil {

return nil, fmt.Errorf("error creating request: %w", err)

}

a.setHeaders(req)

resp, err := a.do(ctx, req, "/user")

if err != nil {

return nil, fmt.Errorf("error making request: %w", err)

}

defer resp.Body.Close()

if resp.StatusCode != http.StatusOK {

return nil, api.HandleHTTPError(resp)

}

b, err := io.ReadAll(resp.Body)

if err != nil {

return nil, fmt.Errorf("error reading response body: %w", err)

}

var response User

if err := json.Unmarshal(b, &response); err != nil {

return nil, fmt.Errorf("error unmarshalling response: %w", err)

}

return &response, nil

ID int `json:"id"`

FullName string `json:"full_name"`

DefaultBranch string `json:"default_branch"`

Owner RepositoryOwner `json:"owner"`

req, err := http.NewRequest(http.MethodGet, a.githubAPI+"/repos/"+strings.ToLower(nwo), nil)

if err != nil {

return nil, fmt.Errorf("error creating request: %w", err)

}

a.setHeaders(req)

resp, err := a.do(ctx, req, "/repos/*")

if err != nil {

return nil, fmt.Errorf("error making request: %w", err)

}

defer resp.Body.Close()

if resp.StatusCode != http.StatusOK {

return nil, api.HandleHTTPError(resp)

}

b, err := io.ReadAll(resp.Body)

if err != nil {

return nil, fmt.Errorf("error reading response body: %w", err)

}

var response Repository

if err := json.Unmarshal(b, &response); err != nil {

return nil, fmt.Errorf("error unmarshalling response: %w", err)

}

return &response, nil

Name string `json:"name"`

CreatedAt string `json:"created_at"`

DisplayName string `json:"display_name"`

LastUsedAt string `json:"last_used_at"`

Owner User `json:"owner"`

Repository Repository `json:"repository"`

State string `json:"state"`

GitStatus CodespaceGitStatus `json:"git_status"`

Connection CodespaceConnection `json:"connection"`

Machine CodespaceMachine `json:"machine"`

RuntimeConstraints RuntimeConstraints `json:"runtime_constraints"`

VSCSTarget string `json:"vscs_target"`

PendingOperation bool `json:"pending_operation"`

PendingOperationDisabledReason string `json:"pending_operation_disabled_reason"`

IdleTimeoutNotice string `json:"idle_timeout_notice"`

WebURL string `json:"web_url"`

DevContainerPath string `json:"devcontainer_path"`

Prebuild bool `json:"prebuild"`

Location string `json:"location"`

IdleTimeoutMinutes int `json:"idle_timeout_minutes"`

RetentionPeriodMinutes int `json:"retention_period_minutes"`

RetentionExpiresAt string `json:"retention_expires_at"`

RecentFolders []string `json:"recent_folders"`

BillableOwner User `json:"billable_owner"`

EnvironmentId string `json:"environment_id"`

Ahead int `json:"ahead"`

Behind int `json:"behind"`

Ref string `json:"ref"`

HasUnpushedChanges bool `json:"has_unpushed_changes"`

HasUncommittedChanges bool `json:"has_uncommitted_changes"`

Name string `json:"name"`

DisplayName string `json:"display_name"`

OperatingSystem string `json:"operating_system"`

StorageInBytes uint64 `json:"storage_in_bytes"`

MemoryInBytes uint64 `json:"memory_in_bytes"`

CPUCount int `json:"cpus"`

ConnectAccessToken string `json:"connectAccessToken"`

ManagePortsAccessToken string `json:"managePortsAccessToken"`

ServiceUri string `json:"serviceUri"`

TunnelId string `json:"tunnelId"`

ClusterId string `json:"clusterId"`

Domain string `json:"domain"`

v := reflect.ValueOf(c).Elem()

data := map[string]interface{}{}

for _, f := range fields {

switch f {

case "owner":

data[f] = c.Owner.Login

case "repository":

data[f] = c.Repository.FullName

case "machineName":

data[f] = c.Machine.Name

case "machineDisplayName":

data[f] = c.Machine.DisplayName

case "retentionPeriodDays":

data[f] = c.RetentionPeriodMinutes / 1440

case "gitStatus":

data[f] = map[string]interface{}{

"ref": c.GitStatus.Ref,

"hasUnpushedChanges": c.GitStatus.HasUnpushedChanges,

"hasUncommittedChanges": c.GitStatus.HasUncommittedChanges,

"ahead": c.GitStatus.Ahead,

"behind": c.GitStatus.Behind,

}

case "vscsTarget":

if c.VSCSTarget != "" && c.VSCSTarget != VSCSTargetProduction {

data[f] = c.VSCSTarget

}

default:

sf := v.FieldByNameFunc(func(s string) bool {

return strings.EqualFold(f, s)

})

data[f] = sf.Interface()

}

}

return data

OrgName string

UserName string

RepoName string

Limit int

var (

perPage = 100

limit = opts.Limit

)

if limit > 0 && limit < 100 {

perPage = limit

}

var (

listURL string

spanName string

)

if opts.RepoName != "" {

listURL = fmt.Sprintf("%s/repos/%s/codespaces?per_page=%d", a.githubAPI, opts.RepoName, perPage)

spanName = "/repos/*/codespaces"

} else if opts.OrgName != "" {

// the endpoints below can only be called by the organization admins

orgName := opts.OrgName

if opts.UserName != "" {

userName := opts.UserName

listURL = fmt.Sprintf("%s/orgs/%s/members/%s/codespaces?per_page=%d", a.githubAPI, orgName, userName, perPage)

spanName = "/orgs/*/members/*/codespaces"

} else {

listURL = fmt.Sprintf("%s/orgs/%s/codespaces?per_page=%d", a.githubAPI, orgName, perPage)

spanName = "/orgs/*/codespaces"

}

} else {

listURL = fmt.Sprintf("%s/user/codespaces?per_page=%d", a.githubAPI, perPage)

spanName = "/user/codespaces"

}

for {

req, err := http.NewRequest(http.MethodGet, listURL, nil)

if err != nil {

return nil, fmt.Errorf("error creating request: %w", err)

}

a.setHeaders(req)

resp, err := a.do(ctx, req, spanName)

if err != nil {

return nil, fmt.Errorf("error making request: %w", err)

}

defer resp.Body.Close()

if resp.StatusCode != http.StatusOK {

return nil, api.HandleHTTPError(resp)

}

var response struct {

Codespaces []*Codespace `json:"codespaces"`

}

dec := json.NewDecoder(resp.Body)

if err := dec.Decode(&response); err != nil {

return nil, fmt.Errorf("error unmarshalling response: %w", err)

}

nextURL := findNextPage(resp.Header.Get("Link"))

codespaces = append(codespaces, response.Codespaces...)

if nextURL == "" || (limit > 0 && len(codespaces) >= limit) {

break

}

if newPerPage := limit - len(codespaces); limit > 0 && newPerPage < 100 {

u, _ := url.Parse(nextURL)

q := u.Query()

q.Set("per_page", strconv.Itoa(newPerPage))

u.RawQuery = q.Encode()

listURL = u.String()

} else {

listURL = nextURL

}

}

return codespaces, nil

for _, m := range linkRE.FindAllStringSubmatch(linkValue, -1) {

if len(m) > 2 && m[2] == "next" {

return m[1]

}

}

return ""

perPage := 100

listURL := fmt.Sprintf("%s/orgs/%s/members/%s/codespaces?per_page=%d", a.githubAPI, orgName, userName, perPage)

for {

req, err := http.NewRequest(http.MethodGet, listURL, nil)

if err != nil {

return nil, fmt.Errorf("error creating request: %w", err)

}

a.setHeaders(req)

resp, err := a.do(ctx, req, "/orgs/*/members/*/codespaces")

if err != nil {

return nil, fmt.Errorf("error making request: %w", err)

}

defer resp.Body.Close()

if resp.StatusCode != http.StatusOK {

return nil, api.HandleHTTPError(resp)

}

var response struct {

Codespaces []*Codespace `json:"codespaces"`

}

dec := json.NewDecoder(resp.Body)

if err := dec.Decode(&response); err != nil {

return nil, fmt.Errorf("error unmarshalling response: %w", err)

}

for _, cs := range response.Codespaces {

if cs.Name == codespaceName {

return cs, nil

}

}

nextURL := findNextPage(resp.Header.Get("Link"))

if nextURL == "" {

break

}

listURL = nextURL

}

return nil, fmt.Errorf("codespace not found for user %s with name %s", userName, codespaceName)

resp, err := a.withRetry(func() (*http.Response, error) {

req, err := http.NewRequest(

http.MethodGet,

a.githubAPI+"/user/codespaces/"+codespaceName,

nil,

)

if err != nil {

return nil, fmt.Errorf("error creating request: %w", err)

}

if includeConnection {

q := req.URL.Query()

q.Add("internal", "true")

q.Add("refresh", "true")

req.URL.RawQuery = q.Encode()

}

a.setHeaders(req)

return a.do(ctx, req, "/user/codespaces/*")

})

if err != nil {

return nil, fmt.Errorf("error making request: %w", err)

}

defer resp.Body.Close()

if resp.StatusCode != http.StatusOK {

return nil, api.HandleHTTPError(resp)

}

b, err := io.ReadAll(resp.Body)

if err != nil {

return nil, fmt.Errorf("error reading response body: %w", err)

}

var response Codespace

if err := json.Unmarshal(b, &response); err != nil {

return nil, fmt.Errorf("error unmarshalling response: %w", err)

}

return &response, nil

resp, err := a.withRetry(func() (*http.Response, error) {

req, err := http.NewRequest(

http.MethodPost,

a.githubAPI+"/user/codespaces/"+codespaceName+"/start",

nil,

)

if err != nil {

return nil, fmt.Errorf("error creating request: %w", err)

}

a.setHeaders(req)

return a.do(ctx, req, "/user/codespaces/*/start")

})

if err != nil {

return fmt.Errorf("error making request: %w", err)

}

defer resp.Body.Close()

if resp.StatusCode != http.StatusOK {

if resp.StatusCode == http.StatusConflict {

// 409 means the codespace is already running which we can safely ignore

return nil

}

return api.HandleHTTPError(resp)

}

return nil

var stopURL string

var spanName string

if orgName != "" {

stopURL = fmt.Sprintf("%s/orgs/%s/members/%s/codespaces/%s/stop", a.githubAPI, orgName, userName, codespaceName)

spanName = "/orgs/*/members/*/codespaces/*/stop"

} else {

stopURL = fmt.Sprintf("%s/user/codespaces/%s/stop", a.githubAPI, codespaceName)

spanName = "/user/codespaces/*/stop"

}

req, err := http.NewRequest(http.MethodPost, stopURL, nil)

if err != nil {

return fmt.Errorf("error creating request: %w", err)

}

a.setHeaders(req)

resp, err := a.do(ctx, req, spanName)

if err != nil {

return fmt.Errorf("error making request: %w", err)

}

defer resp.Body.Close()

if resp.StatusCode != http.StatusOK {

return api.HandleHTTPError(resp)

}

return nil

Name string `json:"name"`

DisplayName string `json:"display_name"`

PrebuildAvailability string `json:"prebuild_availability"`

reqURL := fmt.Sprintf("%s/repositories/%d/codespaces/machines", a.githubAPI, repoID)

req, err := http.NewRequest(http.MethodGet, reqURL, nil)

if err != nil {

return nil, fmt.Errorf("error creating request: %w", err)

}

q := req.URL.Query()

q.Add("location", location)

q.Add("ref", branch)

q.Add("devcontainer_path", devcontainerPath)

req.URL.RawQuery = q.Encode()

a.setHeaders(req)

resp, err := a.do(ctx, req, "/repositories/*/codespaces/machines")

if err != nil {

return nil, fmt.Errorf("error making request: %w", err)

}

defer resp.Body.Close()

if resp.StatusCode != http.StatusOK {

return nil, api.HandleHTTPError(resp)

}

b, err := io.ReadAll(resp.Body)

if err != nil {

return nil, fmt.Errorf("error reading response body: %w", err)

}

var response struct {

Machines []*Machine `json:"machines"`

}

if err := json.Unmarshal(b, &response); err != nil {

return nil, fmt.Errorf("error unmarshalling response: %w", err)

}

return response.Machines, nil

reqURL := fmt.Sprintf("%s/repositories/%d/codespaces/permissions_check", a.githubAPI, repoID)

req, err := http.NewRequest(http.MethodGet, reqURL, nil)

if err != nil {

return false, fmt.Errorf("error creating request: %w", err)

}

q := req.URL.Query()

q.Add("ref", branch)

q.Add("devcontainer_path", devcontainerPath)

req.URL.RawQuery = q.Encode()

a.setHeaders(req)

resp, err := a.do(ctx, req, "/repositories/*/codespaces/permissions_check")

if err != nil {

return false, fmt.Errorf("error making request: %w", err)

}

defer resp.Body.Close()

if resp.StatusCode != http.StatusOK {

return false, api.HandleHTTPError(resp)

}

b, err := io.ReadAll(resp.Body)

if err != nil {

return false, fmt.Errorf("error reading response body: %w", err)

}

var response struct {

Accepted bool `json:"accepted"`

}

if err := json.Unmarshal(b, &response); err != nil {

return false, fmt.Errorf("error unmarshalling response: %w", err)

}

return response.Accepted, nil

// The maximum number of repos to return. At most 100 repos are returned even if this value is greater than 100.

MaxRepos int

// The sort order for returned repos. Possible values are 'stars', 'forks', 'help-wanted-issues', or 'updated'. If empty the API's default ordering is used.

Sort string

reqURL := fmt.Sprintf("%s/search/repositories", a.githubAPI)

req, err := http.NewRequest(http.MethodGet, reqURL, nil)

if err != nil {

return nil, fmt.Errorf("error creating request: %w", err)

}

parts := strings.SplitN(partialSearch, "/", 2)

var nameSearch string

if len(parts) == 2 {

user := parts[0]

repo := parts[1]

nameSearch = fmt.Sprintf("%s user:%s", repo, user)

} else {

/*

nameSearch = partialSearch

}

queryStr := fmt.Sprintf("%s in:name", nameSearch)

q := req.URL.Query()

q.Add("q", queryStr)

if len(parameters.Sort) > 0 {

q.Add("sort", parameters.Sort)

}

if parameters.MaxRepos > 0 {

q.Add("per_page", strconv.Itoa(parameters.MaxRepos))

}

req.URL.RawQuery = q.Encode()

a.setHeaders(req)

resp, err := a.do(ctx, req, "/search/repositories/*")

if err != nil {

return nil, fmt.Errorf("error searching repositories: %w", err)

}

defer resp.Body.Close()

if resp.StatusCode != http.StatusOK {

return nil, api.HandleHTTPError(resp)

}

b, err := io.ReadAll(resp.Body)

if err != nil {

return nil, fmt.Errorf("error reading response body: %w", err)

}

var response struct {

Items []*Repository `json:"items"`

}

if err := json.Unmarshal(b, &response); err != nil {

return nil, fmt.Errorf("error unmarshalling response: %w", err)

}

repoNames := make([]string, len(response.Items))

for i, repo := range response.Items {

repoNames[i] = repo.FullName

}

return repoNames, nil

req, err := http.NewRequest(http.MethodGet, a.githubAPI+"/repos/"+nwo+"/codespaces/new", nil)

if err != nil {

return nil, fmt.Errorf("error creating request: %w", err)

}

a.setHeaders(req)

resp, err := a.do(ctx, req, "/repos/*/codespaces/new")

if err != nil {

return nil, fmt.Errorf("error making request: %w", err)

}

defer resp.Body.Close()

if resp.StatusCode == http.StatusNotFound {

return nil, nil

} else if resp.StatusCode == http.StatusForbidden {

return nil, fmt.Errorf("you cannot create codespaces with that repository")

} else if resp.StatusCode != http.StatusOK {

return nil, api.HandleHTTPError(resp)

}

b, err := io.ReadAll(resp.Body)

if err != nil {

return nil, fmt.Errorf("error reading response body: %w", err)

}

var response struct {

BillableOwner User `json:"billable_owner"`

Defaults struct {

DevcontainerPath string `json:"devcontainer_path"`

Location string `json:"location"`

}

}

if err := json.Unmarshal(b, &response); err != nil {

return nil, fmt.Errorf("error unmarshalling response: %w", err)

}

// While this response contains further helpful information ahead of codespace creation,

// we're only referencing the billable owner today.

return &response.BillableOwner, nil

RepositoryID int

IdleTimeoutMinutes int

RetentionPeriodMinutes *int

Branch string

Machine string

Location string

DevContainerPath string

VSCSTarget string

VSCSTargetURL string

PermissionsOptOut bool

DisplayName string

codespace, err := a.startCreate(ctx, params)

if !errors.Is(err, errProvisioningInProgress) {

return codespace, err

}

// errProvisioningInProgress indicates that codespace creation did not complete

// within the GitHub API RPC time limit (10s), so it continues asynchronously.

// We must poll the server to discover the outcome.

ctx, cancel := context.WithTimeout(ctx, 2*time.Minute)

defer cancel()

ticker := time.NewTicker(1 * time.Second)

defer ticker.Stop()

for {

select {

case <-ctx.Done():

return nil, ctx.Err()

case <-ticker.C:

codespace, err = a.GetCodespace(ctx, codespace.Name, false)

if err != nil {

return nil, fmt.Errorf("failed to get codespace: %w", err)

}

// we continue to poll until the codespace shows as provisioned

if codespace.State != CodespaceStateAvailable {

continue

}

return codespace, nil

}

}

RepositoryID int `json:"repository_id"`

IdleTimeoutMinutes int `json:"idle_timeout_minutes,omitempty"`

RetentionPeriodMinutes *int `json:"retention_period_minutes,omitempty"`

Ref string `json:"ref"`

Location string `json:"location"`

Machine string `json:"machine"`

DevContainerPath string `json:"devcontainer_path,omitempty"`

VSCSTarget string `json:"vscs_target,omitempty"`

VSCSTargetURL string `json:"vscs_target_url,omitempty"`

PermissionsOptOut bool `json:"multi_repo_permissions_opt_out"`

DisplayName string `json:"display_name"`

if params == nil {

return nil, errors.New("startCreate missing parameters")

}

requestBody, err := json.Marshal(startCreateRequest{

RepositoryID: params.RepositoryID,

IdleTimeoutMinutes: params.IdleTimeoutMinutes,

RetentionPeriodMinutes: params.RetentionPeriodMinutes,

Ref: params.Branch,

Location: params.Location,

Machine: params.Machine,

DevContainerPath: params.DevContainerPath,

VSCSTarget: params.VSCSTarget,

VSCSTargetURL: params.VSCSTargetURL,

PermissionsOptOut: params.PermissionsOptOut,

DisplayName: params.DisplayName,

})

if err != nil {

return nil, fmt.Errorf("error marshaling request: %w", err)

}

req, err := http.NewRequest(http.MethodPost, a.githubAPI+"/user/codespaces", bytes.NewBuffer(requestBody))

if err != nil {

return nil, fmt.Errorf("error creating request: %w", err)

}

a.setHeaders(req)

resp, err := a.do(ctx, req, "/user/codespaces")

if err != nil {

return nil, fmt.Errorf("error making request: %w", err)

}

defer resp.Body.Close()

if resp.StatusCode == http.StatusAccepted {

b, err := io.ReadAll(resp.Body)

if err != nil {

return nil, fmt.Errorf("error reading response body: %w", err)

}

var response Codespace

if err := json.Unmarshal(b, &response); err != nil {

return nil, fmt.Errorf("error unmarshalling response: %w", err)

}

return &response, errProvisioningInProgress // RPC finished before result of creation known

} else if resp.StatusCode == http.StatusUnauthorized {

var (

ue AcceptPermissionsRequiredError

bodyCopy = &bytes.Buffer{}

r = io.TeeReader(resp.Body, bodyCopy)

)

b, err := io.ReadAll(r)

if err != nil {

return nil, fmt.Errorf("error reading response body: %w", err)

}

if err := json.Unmarshal(b, &ue); err != nil {

return nil, fmt.Errorf("error unmarshalling response: %w", err)

}

if ue.AllowPermissionsURL != "" {

return nil, ue

}

resp.Body = io.NopCloser(bodyCopy)

return nil, api.HandleHTTPError(resp)

} else if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusCreated {

return nil, api.HandleHTTPError(resp)

}

b, err := io.ReadAll(resp.Body)

if err != nil {

return nil, fmt.Errorf("error reading response body: %w", err)

}

var response Codespace

if err := json.Unmarshal(b, &response); err != nil {

return nil, fmt.Errorf("error unmarshalling response: %w", err)

}

return &response, nil

var deleteURL string

var spanName string

if orgName != "" && userName != "" {

deleteURL = fmt.Sprintf("%s/orgs/%s/members/%s/codespaces/%s", a.githubAPI, orgName, userName, codespaceName)

spanName = "/orgs/*/members/*/codespaces/*"

} else {

deleteURL = a.githubAPI + "/user/codespaces/" + codespaceName

spanName = "/user/codespaces/*"

}

req, err := http.NewRequest(http.MethodDelete, deleteURL, nil)

if err != nil {

return fmt.Errorf("error creating request: %w", err)

}

a.setHeaders(req)

resp, err := a.do(ctx, req, spanName)

if err != nil {

return fmt.Errorf("error making request: %w", err)

}

defer resp.Body.Close()

if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusAccepted {

return api.HandleHTTPError(resp)

}