GitLabgitlab-org

cli

main
ply7 git calls215 ms101 KiB5 cachedprotocol v2
247 lines10 KiBRaw

Make an authenticated request to the GitLab API.

Synopsis

Makes an authenticated HTTP request to the GitLab API, and prints the response. Specify either a path to a GitLab API v4 endpoint, or graphql to access the GitLab GraphQL API.

For more information, see:

If the current directory is a Git directory, this command uses the GitLab authenticated host in the current directory. Otherwise, gitlab.com is used. To override the GitLab hostname, use --hostname.

When used in the endpoint argument, these placeholder values are replaced with values from the repository of the current directory:

  • :branch
  • :fullpath
  • :group
  • :id
  • :namespace
  • :repo
  • :user
  • :username

To define your own placeholder, pass --placeholder <name>=<value> and use :<name> in the endpoint or in --field values. In the endpoint, the value is encoded as a single path segment. In --field values, it is sent unchanged. To put a value in a query string, pass it as a field instead: -X GET -F <key>=:<name>. A custom placeholder cannot reuse the name of a built-in placeholder.

The default HTTP request method is GET when no parameters are added, and POST otherwise. To override the method, use --method.

Pass one or more --raw-field values in key=value format to add JSON-encoded string parameters to the POST body.

The --field flag behaves like --raw-field but converts values based on their format:

  • Literal values true, false, null, and integer numbers are converted to the matching JSON types.
  • Values starting with [ or { are parsed as JSON arrays or objects (e.g. -F 'topics=["my-topic","GitLab"]'). Invalid JSON returns an error. The value must start with the bracket or brace: a leading space, as in -F 'topics= ["a"]', is part of the value, so it is sent as a string.
  • Placeholder values :namespace, :repo, and :branch are populated with values from the repository of the current directory, including inside JSON arrays and objects (e.g. -F 'input={"projectPath":":fullpath"}').
  • If the value starts with @, the rest of the value is interpreted as a filename to read the value from. Pass - to read from standard input.

--raw-field does not parse JSON arrays or objects; those values are sent as strings. To pass a JSON body literally, use --input.

A bracketed --raw-field value such as -f 'scopes=[api,read_api]' is sent as the literal string "[api,read_api]". Earlier versions converted that shape into an array on request bodies, which --raw-field never documented. Use -F 'scopes=["api","read_api"]' for an array.

Field names are never parsed. A bracketed name is only meaningful where the fields become URL query parameters. That means GET and DELETE requests, and any request where --input supplies the body. There the name is used literally and percent-encoded, so -f 'position[base_sha]=abc' arrives as the nested parameter it describes.

A name ending in [] collects values instead of holding one, which is how the API reads an array. Repeating the name sends every value, in the order the flags were given: -X GET -f 'ids[]=1' -f 'ids[]=2' sends both. Because every value is sent, --field does not override --raw-field of the same name, as it does for other names.

Any other name holds a single value. Among values from the same flag, the last one wins. When both flags name it, the --field value wins, whichever order the two were given in.

The -F 'ids=[1,2]' spelling emits ids[] as well. Spelling one query parameter both ways is therefore an error. Passing -f 'ids[]=1' with -F 'ids=[2,3]' is rejected, because nothing says which order the three values belong in.

In a JSON request body a field name containing a bracket is an error. Such a name would be sent as a single literal key, which the API ignores. The request would succeed without doing what the name asked. Pass the value as JSON instead, as in -F 'position={"base_sha":"abc"}' or -F 'ids=[1,2]'. Or use --input.

With no --method, adding any field makes the request a POST. Sending bracketed names as query parameters therefore needs an explicit --method GET. --form is unaffected: its part names are always literal.

For GraphQL requests, all fields other than query and operationName are interpreted as GraphQL variables. The bracket rule applies to them unchanged: where the request sends a JSON body, a bracketed variable name is an error.

To send data as multipart/form-data instead of JSON, use --form. This is required for API endpoints that accept file uploads, such as wiki attachments. Pass one or more --form values in key=value format. To upload a file, prefix the value with @ followed by the file path. Pass - to read from standard input. Do not combine --form with --field, --raw-field, or --input.

To pass a raw request body, use --input with a file path. Pass - to read from standard input. In this mode, parameters specified with --field flags are serialized into URL query parameters.

A --input body is sent as application/json, which is what most GitLab endpoints require to parse it. To send a body of another type, set the header yourself with --header 'Content-Type: ...'; an explicit header is never overridden.

In --paginate mode, all pages of results are requested sequentially until no more pages of results remain. For GraphQL requests:

  • The original query must accept an $endCursor: String variable.
  • The query must fetch the pageInfo{ hasNextPage, endCursor } set of fields from a collection.

glab api does not retry a failed request. When GitLab answers with HTTP 429, glab api exits with an error that says how long to wait before you retry, taken from the Retry-After or RateLimit-Reset response header.

The --output flag controls the output format:

  • json (default): Pretty-printed JSON. Arrays are output as a single JSON array.
  • ndjson: Newline-delimited JSON, also known as JSON Lines. Each array element or object is output on a separate line. This format is more memory-efficient for large datasets and works well with tools like jq.

For ndjson format specifications, see the ndjson spec and JSON Lines.

plaintext
glab api <endpoint> [flags]

Examples

console
# List releases for the current project, expanding the :fullpath placeholder
glab api projects/:fullpath/releases

# List issues for a project by URL-encoded path
glab api projects/gitlab-com%2Fwww-gitlab-com/issues

# Get a branch whose name contains a slash, using a custom placeholder
glab api projects/:fullpath/repository/branches/:target --placeholder target=feature/login

# Upload a file to a project wiki
glab api --method POST projects/:fullpath/wikis/attachments --form "file=@./image.png" --form "branch=main"

# Debug the HTTP request and response, including headers and body.
# Use --input to send a complete JSON request body from stdin.
echo '{"allowed_to_push":[{"user_id":1}]}' | GLAB_DEBUG_HTTP=1 glab api -X PATCH "projects/:fullpath/protected_branches/main" --input -

# Fetch all pages of issues
glab api issues --paginate

# Fetch all pages of issues as newline-delimited JSON
glab api issues --paginate --output ndjson

# Pipe paginated output to jq to filter open issues
glab api issues --paginate --output ndjson | jq 'select(.state == "opened")'

# Run a simple GraphQL query
glab api graphql -f query="query { currentUser { username } }"

# Run a multi-line GraphQL query for project metadata
glab api graphql -f query='
  query {
    project(fullPath: "gitlab-org/gitlab-docs") {
      name
      forksCount
      statistics {
        wikiSize
      }
      issuesEnabled
      boards {
        nodes {
          id
          name
        }
      }
    }
  }
'

# Run a paginated GraphQL query using an endCursor variable
glab api graphql --paginate -f query='
  query($endCursor: String) {
    project(fullPath: "gitlab-org/graphql-sandbox") {
      name
      issues(first: 2, after: $endCursor) {
        edges {
          node {
            title
          }
        }
        pageInfo {
          endCursor
          hasNextPage
        }
      }
    }
  }'

Environment variables

plaintext
GITLAB_TOKEN, OAUTH_TOKEN (in order of precedence): an authentication token for API requests.
GITLAB_HOST, GITLAB_URI, GITLAB_URL: specify a GitLab host to make request to.
GLAB_DEBUG_HTTP: print the full HTTP request and response, including headers and body, to stderr.

Options

plaintext
  -F, --field stringArray         Add a parameter of inferred type. Using this flag changes the default HTTP method to POST.
      --form stringArray          Add a multipart form field. To upload a file, prefix the value with @ followed by the file path. To read from standard input, use @- (at most once). Using this flag changes the default HTTP method to POST.
  -H, --header stringArray        Add an additional HTTP request header.
      --hostname string           The GitLab hostname for the request. Defaults to gitlab.com, or the authenticated host in the current Git directory.
  -i, --include                   Include HTTP response headers in the output.
      --input string              The file to use as the body for the HTTP request. Sent as 'application/json' unless you set another 'Content-Type' with --header.
  -X, --method string             The HTTP method for the request. (default "GET")
      --output string             Format output as: json, ndjson. (default "json")
      --paginate                  Make additional HTTP requests to fetch all pages of results.
      --placeholder stringArray   Define a custom placeholder in <name>=<value> format, expanded from :<name>. Repeat the flag to define more than one.
  -f, --raw-field stringArray     Add a string parameter.
      --silent                    Do not print the response body.

Options inherited from parent commands

plaintext
  -h, --help   Show help for this command.
1---
2title: '`glab api`'
3stage: AI Clients
4group: Developer Clients
5info: To determine the technical writer assigned to the Stage/Group associated with this page, see <https://handbook.gitlab.com/handbook/marketing/product-and-technical-marketing/technical-writing/#assignments>
6---
8<!--
9This documentation is auto generated by a script.
10Please do not edit this file directly. Run `make gen-docs` instead.
11-->
13Make an authenticated request to the GitLab API.
15## Synopsis
17Makes an authenticated HTTP request to the GitLab API, and prints the response.
18Specify either a path to a GitLab API v4 endpoint, or `graphql` to access the
19GitLab GraphQL API.
21For more information, see:
23- [GitLab REST API documentation](https://docs.gitlab.com/api/)
24- [GitLab GraphQL documentation](https://docs.gitlab.com/api/graphql/)
26If the current directory is a Git directory, this command uses the GitLab
27authenticated host in the current directory. Otherwise, `gitlab.com` is used.
28To override the GitLab hostname, use `--hostname`.
30When used in the endpoint argument, these placeholder values are replaced
31with values from the repository of the current directory:
33- `:branch`
34- `:fullpath`
35- `:group`
36- `:id`
37- `:namespace`
38- `:repo`
39- `:user`
40- `:username`
42To define your own placeholder, pass `--placeholder <name>=<value>` and use `:<name>` in the endpoint or in `--field` values. In the endpoint, the value is encoded as a single path segment. In `--field` values, it is sent unchanged. To put a value in a query string, pass it as a field instead: `-X GET -F <key>=:<name>`. A custom placeholder cannot reuse the name of a built-in placeholder.
44The default HTTP request method is `GET` when no parameters are added,
45and `POST` otherwise. To override the method, use `--method`.
47Pass one or more `--raw-field` values in `key=value` format to add
48JSON-encoded string parameters to the `POST` body.
50The `--field` flag behaves like `--raw-field` but converts values
51based on their format:
53- Literal values `true`, `false`, `null`, and integer numbers are converted to
54 the matching JSON types.
55- Values starting with `[` or `{` are parsed as JSON arrays or objects
56 (e.g. `-F 'topics=["my-topic","GitLab"]'`). Invalid JSON returns an error.
57 The value must start with the bracket or brace: a leading space, as in
58 `-F 'topics= ["a"]'`, is part of the value, so it is sent as a string.
59- Placeholder values `:namespace`, `:repo`, and `:branch` are populated with values
60 from the repository of the current directory, including inside JSON
61 arrays and objects (e.g. `-F 'input={"projectPath":":fullpath"}'`).
62- If the value starts with `@`, the rest of the value is interpreted as a
63 filename to read the value from. Pass `-` to read from standard input.
65`--raw-field` does not parse JSON arrays or objects; those values are
66sent as strings. To pass a JSON body literally, use `--input`.
68A bracketed `--raw-field` value such as `-f 'scopes=[api,read_api]'` is sent as
69the literal string `"[api,read_api]"`. Earlier versions converted that shape
70into an array on request bodies, which `--raw-field` never documented. Use
71`-F 'scopes=["api","read_api"]'` for an array.
73Field names are never parsed. A bracketed name is only meaningful where the
74fields become URL query parameters. That means `GET` and `DELETE` requests,
75and any request where `--input` supplies the body. There the name is used
76literally and percent-encoded, so `-f 'position[base_sha]=abc'` arrives as
77the nested parameter it describes.
79A name ending in `[]` collects values instead of holding one, which is how
80the API reads an array. Repeating the name sends every value, in the order
81the flags were given: `-X GET -f 'ids[]=1' -f 'ids[]=2'` sends both.
82Because every value is sent, `--field` does not override `--raw-field` of
83the same name, as it does for other names.
85Any other name holds a single value. Among values from the same flag, the
86last one wins. When both flags name it, the `--field` value wins, whichever
87order the two were given in.
89The `-F 'ids=[1,2]'` spelling emits `ids[]` as well. Spelling one query
90parameter both ways is therefore an error. Passing `-f 'ids[]=1'` with
91`-F 'ids=[2,3]'` is rejected, because nothing says which order the three
92values belong in.
94In a JSON request body a field name containing a bracket is an error. Such
95a name would be sent as a single literal key, which the API ignores. The
96request would succeed without doing what the name asked. Pass the value as
97JSON instead, as in `-F 'position={"base_sha":"abc"}'` or `-F 'ids=[1,2]'`.
98Or use `--input`.
100With no `--method`, adding any field makes the request a `POST`. Sending
101bracketed names as query parameters therefore needs an explicit
102`--method GET`. `--form` is unaffected: its part names are always literal.
104For GraphQL requests, all fields other than `query` and `operationName` are
105interpreted as GraphQL variables. The bracket rule applies to them
106unchanged: where the request sends a JSON body, a bracketed variable name
107is an error.
109To send data as `multipart/form-data` instead of JSON, use `--form`. This is
110required for API endpoints that accept file uploads, such as wiki attachments.
111Pass one or more `--form` values in `key=value` format. To upload a file,
112prefix the value with `@` followed by the file path. Pass `-` to read from
113standard input. Do not combine `--form` with `--field`, `--raw-field`, or `--input`.
115To pass a raw request body, use `--input` with a file path. Pass `-` to
116read from standard input. In this mode, parameters specified with `--field`
117flags are serialized into URL query parameters.
119A `--input` body is sent as `application/json`, which is what most GitLab
120endpoints require to parse it. To send a body of another type, set the
121header yourself with `--header 'Content-Type: ...'`; an explicit header is
122never overridden.
124In `--paginate` mode, all pages of results are requested sequentially until
125no more pages of results remain. For GraphQL requests:
127- The original query must accept an `$endCursor: String` variable.
128- The query must fetch the `pageInfo{ hasNextPage, endCursor }` set of fields from a collection.
130`glab api` does not retry a failed request. When GitLab answers with HTTP 429, `glab api` exits with an error that says how long to wait before you retry, taken from the `Retry-After` or `RateLimit-Reset` response header.
132The `--output` flag controls the output format:
134- `json` (default): Pretty-printed JSON. Arrays are output as a single JSON array.
135- `ndjson`: Newline-delimited JSON, also known as JSON Lines. Each array element
136 or object is output on a separate line. This format is more memory-efficient for
137 large datasets and works well with tools like `jq`.
139For ndjson format specifications, see the
140[ndjson spec](https://github.com/ndjson/ndjson-spec) and [JSON Lines](https://jsonlines.org/).
142```plaintext
143glab api <endpoint> [flags]
144```
146## Examples
148```console
149# List releases for the current project, expanding the :fullpath placeholder
150glab api projects/:fullpath/releases
152# List issues for a project by URL-encoded path
153glab api projects/gitlab-com%2Fwww-gitlab-com/issues
155# Get a branch whose name contains a slash, using a custom placeholder
156glab api projects/:fullpath/repository/branches/:target --placeholder target=feature/login
158# Upload a file to a project wiki
159glab api --method POST projects/:fullpath/wikis/attachments --form "file=@./image.png" --form "branch=main"
161# Debug the HTTP request and response, including headers and body.
162# Use --input to send a complete JSON request body from stdin.
163echo '{"allowed_to_push":[{"user_id":1}]}' | GLAB_DEBUG_HTTP=1 glab api -X PATCH "projects/:fullpath/protected_branches/main" --input -
165# Fetch all pages of issues
166glab api issues --paginate
168# Fetch all pages of issues as newline-delimited JSON
169glab api issues --paginate --output ndjson
171# Pipe paginated output to jq to filter open issues
172glab api issues --paginate --output ndjson | jq 'select(.state == "opened")'
174# Run a simple GraphQL query
175glab api graphql -f query="query { currentUser { username } }"
177# Run a multi-line GraphQL query for project metadata
178glab api graphql -f query='
179 query {
180 project(fullPath: "gitlab-org/gitlab-docs") {
181 name
182 forksCount
183 statistics {
184 wikiSize
185 }
186 issuesEnabled
187 boards {
188 nodes {
189 id
190 name
191 }
192 }
193 }
194 }
197# Run a paginated GraphQL query using an endCursor variable
198glab api graphql --paginate -f query='
199 query($endCursor: String) {
200 project(fullPath: "gitlab-org/graphql-sandbox") {
201 name
202 issues(first: 2, after: $endCursor) {
203 edges {
204 node {
205 title
206 }
207 }
208 pageInfo {
209 endCursor
210 hasNextPage
211 }
212 }
213 }
214 }'
216```
218## Environment variables
220```plaintext
221GITLAB_TOKEN, OAUTH_TOKEN (in order of precedence): an authentication token for API requests.
222GITLAB_HOST, GITLAB_URI, GITLAB_URL: specify a GitLab host to make request to.
223GLAB_DEBUG_HTTP: print the full HTTP request and response, including headers and body, to stderr.
224```
226## Options
228```plaintext
229 -F, --field stringArray Add a parameter of inferred type. Using this flag changes the default HTTP method to POST.
230 --form stringArray Add a multipart form field. To upload a file, prefix the value with @ followed by the file path. To read from standard input, use @- (at most once). Using this flag changes the default HTTP method to POST.
231 -H, --header stringArray Add an additional HTTP request header.
232 --hostname string The GitLab hostname for the request. Defaults to gitlab.com, or the authenticated host in the current Git directory.
233 -i, --include Include HTTP response headers in the output.
234 --input string The file to use as the body for the HTTP request. Sent as 'application/json' unless you set another 'Content-Type' with --header.
235 -X, --method string The HTTP method for the request. (default "GET")
236 --output string Format output as: json, ndjson. (default "json")
237 --paginate Make additional HTTP requests to fetch all pages of results.
238 --placeholder stringArray Define a custom placeholder in <name>=<value> format, expanded from :<name>. Repeat the flag to define more than one.
239 -f, --raw-field stringArray Add a string parameter.
240 --silent Do not print the response body.
241```
243## Options inherited from parent commands
245```plaintext
246 -h, --help Show help for this command.
247```
Diagnostics7 git calls · 215 ms
CallStatusSizeTime0215 ms
discover200185 B7 ms
git.upload-pack discover
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=7
git.response.bytes=185
git.server.agent=git/2.56.g1891de4-Linux
git.server.object_format=sha1
git.server.caps=agent ls-refs fetch server-option object-format
git.server.fetch=shallow wait-for-done filter
git.protocol.version=2
git.pkt.frames=9
git.pkt.data=7
git.pkt.flush=2
git.pkt.delim=0
git.pkt.bytes=185
git.pkt.payload.max=35
ls-refs20058 KiB · hit7 ms
git.upload-pack ls-refs
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=7
git.response.bytes=59849
git.response.cache=HIT
git.response.duration_ms=7
git.protocol.version=2
git.pkt.frames=731
git.pkt.data=730
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=59849
git.pkt.payload.max=143
git.ls_refs.count=730
git.ls_refs.head=refs/heads/main
fetchtree:0 · deepen 1020032 KiB · hit3 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=3
git.response.bytes=32926
git.response.cache=HIT
git.response.duration_ms=3
git.fetch.filter=tree:0
git.fetch.wants=0dd7574dce9e385c5c30540e6c15657adc6bdce9
git.fetch.haves.count=0
git.fetch.deepen=10
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=22
git.pkt.data=20
git.pkt.flush=1
git.pkt.delim=1
git.pkt.bytes=32926
git.pkt.payload.max=32046
git.sideband.band1.bytes=32046
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=80
git.pack.bytes=32046
git.pack.ofs_delta=36
git.pack.ref_delta=0
git.pack.chain.max=2
git.pack.trailer=cb0bad5d7ffc514895d8b21c4dd470327f90bc91
git.pack.full=44
Open pack map
fetchcombine:blob:none+tree:2 · deepen 12004.2 KiB · hit6 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=6
git.response.bytes=4273
git.response.cache=HIT
git.response.duration_ms=6
git.fetch.filter=combine:blob:none+tree:2
git.fetch.wants=0dd7574dce9e385c5c30540e6c15657adc6bdce9
git.fetch.haves.count=0
git.fetch.deepen=1
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=7
git.pkt.data=5
git.pkt.flush=1
git.pkt.delim=1
git.pkt.bytes=4273
git.pkt.payload.max=4173
git.sideband.band1.bytes=4173
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=11
git.pack.bytes=4173
git.fetch.wide.objects=11
git.fetch.wide.extra_bytes=3930
git.fetch.wide.blobs=0
fetchtree:02001.7 KiB · hit1 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=1
git.response.bytes=1744
git.response.cache=HIT
git.response.duration_ms=1
git.fetch.filter=tree:0
git.fetch.wants=5e4007a5673eb3bf5d0d7f1a1463c3b2ca3fb3bd
git.fetch.haves.count=0
git.fetch.deepen=0
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=4
git.pkt.data=3
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=1744
git.pkt.payload.max=1717
git.sideband.band1.bytes=1717
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=1717
git.pack.trailer=3f1b9ccc7756e8941d6705e8187c87fd922113e6
Open pack map
fetchtree:0200107 B · hit3 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=3
git.response.bytes=107
git.response.cache=HIT
git.response.duration_ms=3
git.fetch.filter=tree:0
git.fetch.wants=db9270ebd0ad3c3f1e7681cb3a460dc6d0494794
git.fetch.haves.count=0
git.fetch.deepen=0
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=4
git.pkt.data=3
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=107
git.pkt.payload.max=80
git.sideband.band1.bytes=80
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=80
git.pack.trailer=6cef9f655f08b1a923af8f5425853fffdd079c0b
Open pack map
fetch2004.1 KiB198 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=198
git.response.bytes=4233
git.response.cache=MISS
git.response.duration_ms=198
git.fetch.wants=570324b3f3243d4304cb82f5e03589e53911ea88
git.fetch.haves.count=0
git.fetch.deepen=0
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=4
git.pkt.data=3
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=4233
git.pkt.payload.max=4206
git.sideband.band1.bytes=4206
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0

Each row is one HTTP round trip ply made to the git server for this page, on one timeline. discover asks what the server speaks, ls-refs lists branch tips, fetch brings objects by id. A hit was served by Workers Cache. Tap a row for its wire details.

Remote
https://gitlab.com/gitlab-org/cli
Ref
refs/heads/main
Commit
0dd7574dce9e385c5c30540e6c15657adc6bdce9
cf-ray
a5e1301dadafa9fe
Request
5a41345a…
Protocol
v2 · sha1
Agent
git/2.56.g1891de4-Linux
Filter
advertised
Fetch
shallow wait-for-done filter
Capabilities
agent ls-refs fetch server-option object-format