| 1 | --- |
| 2 | title: Projects |
| 3 | description: A project is what you build and run. Its code lives in its source; its deployments, secrets and variables belong to the project. |
| 4 | --- |
| 5 | |
| 6 | A project is the thing you are building and running: a site, an API, a |
| 7 | worker, a library. Every project has one **source**, where its code lives, |
| 8 | and everything about running it belongs to the project: |
| 9 | |
| 10 | | Belongs to the project | Belongs to its repository | |
| 11 | | --- | --- | |
| 12 | | [Deployments](/guides/deployments/): production and previews | Branches and commits | |
| 13 | | Its address on g1t.page | Work items and pull requests | |
| 14 | | [Secrets and variables](/guides/secrets-and-variables/) | Review, merge rules and the [merge queue](/guides/merge-queue/) | |
| 15 | | Its name, description and root directory | Webhooks | |
| 16 | |
| 17 | That split is what lets the code live anywhere while the project stays the |
| 18 | same. |
| 19 | |
| 20 | ## Your projects |
| 21 | |
| 22 | Every repository on g1t is a project of its own name, with nothing to set |
| 23 | up: `g1t.sh/acme/web` is the `web` project, built from the `acme/web` |
| 24 | repository. Repositories made before projects existed became projects the |
| 25 | first time their workspace was opened. |
| 26 | |
| 27 | A workspace's page, `g1t.sh/<workspace>`, shows your pinned projects and |
| 28 | its most active ones, each with where it is deployed, its latest build, and |
| 29 | its open work items and pull requests. **All projects** in the sidebar lists |
| 30 | every one, with search, filters and sorting; see |
| 31 | [the Projects page](/guides/workspaces/#the-projects-page). The sidebar keeps |
| 32 | your [pinned and recent projects](/guides/workspaces/#pinned-and-recent-projects). |
| 33 | |
| 34 | ## A project's pages |
| 35 | |
| 36 | | Page | Address | | |
| 37 | | --- | --- | --- | |
| 38 | | **Overview** | `g1t.sh/<workspace>/<project>` | What it is and its links; production wherever it is deployed, or for a library its packages; what is in progress, active branches, the latest commits, and its About. See [the overview](#the-overview). | |
| 39 | | **Code** | `…/code` | The repository's files, commits and branches. | |
| 40 | | **Work** | `g1t.sh/<workspace>/-/work?repo=<name>` | The workspace's [work items](/guides/work-items/) linked to the repository. | |
| 41 | | **Pull requests**, **Merge queue** | `…/pulls` and so on | As they always were. | |
| 42 | | **Actions** | `…/actions` | [GitHub Actions workflows](/guides/actions/). | |
| 43 | | **Deployments** | `…/deployments` | What is up now and every build. | |
| 44 | | **Settings** | `…/settings` | See below. | |
| 45 | |
| 46 | Every address that pointed into a repository before still works: the |
| 47 | project has the repository's name. |
| 48 | |
| 49 | ## The overview |
| 50 | |
| 51 | A project's overview is the first page you see. It says what the project |
| 52 | is, whether it is running and healthy, and who is working on it right now. |
| 53 | Its files, branches and commits are on **Code**; its pull requests and the |
| 54 | merge queue on **Pull requests** and **Work**. The overview links to them |
| 55 | rather than repeating them. |
| 56 | |
| 57 | People with a [role](/guides/access-and-roles/) on its repository see all |
| 58 | of it; anyone else sees what the project shares publicly: production, its |
| 59 | checks, who is working on it, its deployments and About. |
| 60 | |
| 61 | The production card's header keeps **Visit**, deployment history, and |
| 62 | deployment settings together, with management controls shown according to |
| 63 | your permissions. Hosted projects also offer **Redeploy** there. **Instant |
| 64 | rollback** is marked **Soon** and disabled; it does not change production. |
| 65 | |
| 66 | | Part | What it shows | |
| 67 | | --- | --- | |
| 68 | | **What it is** | A badge, such as **App, deploys itself** or **Library**, beside its homepage and docs. People who can change its settings open the badge to change [what it is](#what-a-project-is) in one click. | |
| 69 | | **Production** | [Production's picture](#productions-picture), which opens the live site, beside the rest. For an app [hosted on g1t.page](/guides/deployments/): its address, the commit it runs and when it went up; **Visit** and **Redeploy**. For an app that deploys itself: production's address and **Visit**, with its latest reported production deployment (and the workflow run that made it, when g1t Actions did) or the default branch's latest commit. For an app nobody has placed yet: one question, where it runs. | |
| 70 | | **Packages** | For a library or a tool, in place of Production: the packages its repository publishes, each with its latest version and how to install it, or how to publish a first one. | |
| 71 | | **Documentation**, **Homepage** | For docs, where they are read; for anything else, its homepage. | |
| 72 | | **Facts** | Under production: its latest release (or, where the card does not already say it, production's state), how often checks pass, and either how many changes pass on the first try and what is open, or, for people with a role when [Observability](/guides/observability/) has data, requests and the error rate over the last day with how many errors are open. | |
| 73 | | **Code** | One line to the repository: its name, default branch and when it was last pushed to, linking to **Code**. | |
| 74 | | **Needs you** | For someone signed in: what is waiting on them, such as a failed production build or a pull request to merge or review. | |
| 75 | | **Live now** | The people and coding agents working on it: each work item with its [claims and sessions](/guides/sessions/), the harness each came from and who it acts for, and sessions on no work item yet. **Sessions** has everything. With nobody working, people with a role see how to [connect a coding agent](/guides/bring-your-own-agent/). | |
| 76 | | **Previews** | For people with a role: the pull requests' previews that are up. | |
| 77 | | **Deployments** | Each environment's latest deployment and when. | |
| 78 | | **Observability** | For people with a role, when there is data: the last day's requests, an hour a bar, latency, and the newest open errors. | |
| 79 | | **About** | Its description, its [links](#links), what it is, and its latest release (its newest tag). People who can change its settings edit the description and links from here. | |
| 80 | | **Health** | For people with a role, its recent builds; and its open work items by age. | |
| 81 | |
| 82 | ### Production's picture |
| 83 | |
| 84 | The production card always has a picture of the app, wherever it runs. |
| 85 | It is the first of these there is: |
| 86 | |
| 87 | 1. **A screenshot of production.** For an app hosted on g1t.page, g1t takes |
| 88 | one each time production goes live (see |
| 89 | [the production screenshot](/guides/deployments/#the-production-screenshot)); |
| 90 | people with a role on the repository see it, like the rest of its |
| 91 | deployments. For an app that deploys itself, g1t takes one of |
| 92 | production's address: the address its latest production deployment |
| 93 | reported to g1t gives, or else the one set for it under **What it is**. |
| 94 | Anyone who can see the project sees it. |
| 95 | 2. **An image someone uploaded**, under **Settings** → **General** → |
| 96 | **Production image**. |
| 97 | 3. **A plain frame** with production's address. People who can change |
| 98 | the project's settings see **Add an image of your app** on it, which |
| 99 | opens **Production image**. |
| 100 | |
| 101 | A screenshot of an app that deploys itself is taken: |
| 102 | |
| 103 | - when its address is set or changed; |
| 104 | - when a production deployment of it is reported to g1t and succeeds, |
| 105 | through the [API](/guides/deployments/) or by a workflow job with an |
| 106 | `environment:`; |
| 107 | - otherwise about once a day, when the one kept is a day old. Opening the |
| 108 | overview after that also takes a new one, in the background, while the |
| 109 | old one shows. |
| 110 | |
| 111 | g1t waits up to 12 seconds for the page to settle, as a 1280 by 800 |
| 112 | browser window sees it, then takes it as it is. Only public `http` and |
| 113 | `https` addresses on their usual ports are visited: an address on a |
| 114 | private network, a loopback or link-local address, or one of g1t's own |
| 115 | service addresses (other than `g1t.sh` itself) gets the uploaded image |
| 116 | or the frame instead. Screenshots are not charged. |
| 117 | |
| 118 | #### Uploading an image |
| 119 | |
| 120 | **Production image** takes a PNG, JPEG or WebP of at most 5 MB; wide |
| 121 | images fit best, such as 1280 by 800. It is checked by its contents, not |
| 122 | its name, and served from g1t's user-content address |
| 123 | (`g1tusercontent.com` on g1t.sh), never from the site itself. Its address |
| 124 | is made from its contents, so the card shows a new image as soon as it |
| 125 | is uploaded. Anyone with an image's address can open it, even for a |
| 126 | private project, so upload only what you would show. |
| 127 | |
| 128 | - The uploaded image shows whenever there is no screenshot: before the |
| 129 | first one, when one cannot be taken, or for an app with no production |
| 130 | address. |
| 131 | - **Use the uploaded image instead of a screenshot** shows it in place of |
| 132 | any screenshot. While it is on, g1t takes no screenshots of an app |
| 133 | that deploys itself. |
| 134 | - **Remove** takes it away; the card goes back to the screenshot or the |
| 135 | frame. |
| 136 | |
| 137 | Anyone who can change the project's settings (the **Maintain** role on |
| 138 | its repository and up, as for production's address) can upload, replace |
| 139 | or remove it. |
| 140 | |
| 141 | ## What a project is |
| 142 | |
| 143 | A project is one of these, and its overview follows: |
| 144 | |
| 145 | | What it is | Its overview shows | |
| 146 | | --- | --- | |
| 147 | | **App or site, hosted on g1t.page** | g1t builds and hosts it: production on g1t.page, with previews and domains. | |
| 148 | | **App or site that deploys itself** | Its own [workflows](/guides/deployments/#deploying-from-a-workflow) on g1t Actions, or another pipeline, deploy it to hosting of its own. Production at the address its deployments report or you give, with **Visit**. It is never asked to turn on Deployments; Deployment settings stay one link away. | |
| 149 | | **Library or package** | The packages its repository publishes and how to install them. | |
| 150 | | **Tool or CLI** | The same as a library: its packages and releases. | |
| 151 | | **Documentation** | Where its docs are read. Docs can be published on g1t.page too, by turning on Deployments. | |
| 152 | | **Something else** | Its homepage and links. | |
| 153 | |
| 154 | Its **Deployments** page stays in the sidebar whatever it is. |
| 155 | |
| 156 | ### How g1t works it out |
| 157 | |
| 158 | Until you say, g1t works it out for itself, in this order: |
| 159 | |
| 160 | 1. If [Deployments](/guides/deployments/) are on for the project, it is |
| 161 | an app hosted on g1t.page. |
| 162 | 2. If its repository publishes a package other than a container image, |
| 163 | such as a [Composer](/guides/composer/) or [npm](/guides/npm/) |
| 164 | package, it is a library. |
| 165 | 3. If the files at the root of its default branch (or of its root |
| 166 | directory) say what it is, it is that: |
| 167 | |
| 168 | | File | Says | |
| 169 | | --- | --- | |
| 170 | | `wrangler.jsonc`, `wrangler.json` or `wrangler.toml` | An app. | |
| 171 | | `mkdocs.yml`, `book.toml`, `docusaurus.config.js` (or `.ts`, `.mjs`) or `antora.yml` | Documentation. | |
| 172 | | `composer.json` | A library when its `type` is anything but `project`, such as `library`; or it has no `type`, has `autoload`, and has no `public/index.php`. | |
| 173 | | `Cargo.toml` | A library when it builds a library (`[lib]` or `src/lib.rs`) and no binary (`[[bin]]` or `src/main.rs`). | |
| 174 | | `go.mod` | A library when no `.go` file at the root is `package main`. | |
| 175 | | `pyproject.toml` | A library when it has a build backend and depends on no app framework, such as Django, Flask or FastAPI. | |
| 176 | | `package.json` | A tool when it has `bin` and nothing to import (no `main`, `module` or `exports`); a library when it has `main`, `exports`, `module`, `files` or `bin`; either way only with no `start` or `dev` script and no app framework such as Next.js, Astro, Nuxt, Remix or SvelteKit. | |
| 177 | |
| 178 | The language's own manifest is read before `package.json`, which many |
| 179 | projects carry only for tooling. An `index.html` at the root makes it |
| 180 | an app. |
| 181 | 4. Anything else is an app. |
| 182 | |
| 183 | The files are read again on every push to the default branch. |
| 184 | |
| 185 | An app found this way runs on g1t only while Deployments are on. Until |
| 186 | you say where it runs, its overview asks, in place of production: |
| 187 | **Deploy on g1t**, **It deploys itself** (with production's |
| 188 | address), or **It isn't deployed** (a library, a tool, documentation or |
| 189 | something else). |
| 190 | |
| 191 | ### Choosing it yourself |
| 192 | |
| 193 | From the overview, open the badge beside its name, such as **App**, and |
| 194 | choose one. Or open **Settings**, then **General**, and under **What it |
| 195 | is** choose **Detect automatically**, which shows what was detected and |
| 196 | why, or one of the kinds above. **App or site that deploys itself** asks |
| 197 | for production's address. |
| 198 | |
| 199 | Choosing a library, a tool or something else while Deployments are on is |
| 200 | refused: turn them off first under **Settings**, then **Deployments**; |
| 201 | g1t does not turn them off for you. While it is set that way, Deployments |
| 202 | cannot be turned on. Turning Deployments on for an app that deploys itself |
| 203 | makes it an app hosted on g1t.page. |
| 204 | |
| 205 | Changing what it is needs the role that changes the project's settings. |
| 206 | |
| 207 | ## Links |
| 208 | |
| 209 | A project has a **homepage**, a **docs** address, and up to 10 other |
| 210 | links, each a label and an address, such as a status page or its listing |
| 211 | in a registry. They show in its overview's About and beside what it is, |
| 212 | on its card on its workspace's page, in its workspace's Projects, and on |
| 213 | Explore for a public project. |
| 214 | |
| 215 | To set them, open **Settings**, then **General**, and fill in **Links**; |
| 216 | or choose the pencil on the overview's **About**. Each is an http or |
| 217 | https address; `https://` is added when you leave it out. A label left |
| 218 | empty is the address's host name. Removing every row of other links |
| 219 | clears them. |
| 220 | |
| 221 | A repository's own project shows the repository's website as its |
| 222 | homepage until you give the project one of its own. For an app deployed |
| 223 | on g1t, its g1t.page address still shows as production; set the homepage |
| 224 | to production's own domain if you have one. |
| 225 | |
| 226 | ## Settings |
| 227 | |
| 228 | A project's **Settings** has a tab for each part: |
| 229 | |
| 230 | | Tab | What it holds | |
| 231 | | --- | --- | |
| 232 | | **General** | The project's name and description, its source, its **root directory**, [what it is](#what-a-project-is), its [links](#links), and its [production image](#uploading-an-image), and its danger zone: archive, [transfer](/guides/transferring-repositories/) and delete, which take its repository with it. Only projects have descriptions: a repository has none of its own, and search, link previews and lists of repositories show its project's. A fork's project starts with the description of the project it was forked from. | |
| 233 | | **Deployments** | Production, previews, build command, output directory and idle days. See [Deployments](/guides/deployments/#settings). | |
| 234 | | **Domains** | Custom domains for production. See [custom domains](/guides/deployments/#custom-domains). | |
| 235 | | **Guardrails** | How long g1t's checks, merge queue and merge checks may run here. See [guardrails](/guides/guardrails/). | |
| 236 | | **Repository** | The repository's name, website, [topics](/guides/search/#what-is-indexed) and default branch, and its danger zone: visibility, and detaching a fork. See [Managing a repository](/guides/managing-repositories/). | |
| 237 | | **Access** | Who has a [role](/guides/access-and-roles/) on the repository, and invitations. | |
| 238 | | **Branches and merging** | Auto-merge, the CODEOWNERS file's errors, and what the rules hold for the default branch. | |
| 239 | | **Rules** | [Rulesets](/guides/rules/): branch and tag protection, [required status checks](/guides/pull-requests/#required-status-checks), approvals and the merge queue, with Insights. | |
| 240 | | **Secrets and variables** | The project's rows. See [Secrets and variables](/guides/secrets-and-variables/). | |
| 241 | | **Runners** | The project's own [self-hosted runners](/guides/self-hosted-runners/). | |
| 242 | | **Webhooks** | The repository's [webhooks](/guides/webhooks/). | |
| 243 | |
| 244 | The **root directory** says where in the repository the project lives, |
| 245 | such as `apps/web`. Builds run there. Leave it empty for the whole |
| 246 | repository. |
| 247 | |
| 248 | Each tab needs a [role](/guides/access-and-roles/) on the project's |
| 249 | repository: |
| 250 | |
| 251 | | Tab | Needs | |
| 252 | | --- | --- | |
| 253 | | **General**, **Dependencies**, **Branches and merging**, and on **Repository** its website and topics | Maintain | |
| 254 | | **Rules**, **Guardrails** | Admin | |
| 255 | | **Access**: seeing who has a role; changing it | Write; Admin | |
| 256 | | **Deployments**, **Domains**, **Secrets and variables**, **Runners**, **Webhooks** | Admin | |
| 257 | | On **Repository**: its name, default branch, and the danger zone (visibility); on **General**, archive | Admin | |
| 258 | | Transfer and delete | An owner of the workspace | |
| 259 | |
| 260 | Someone without the role does not see the tab. |
| 261 | |
| 262 | ## Create a project |
| 263 | |
| 264 | 1. In the workspace the project belongs to, choose **New project** in the |
| 265 | sidebar, or go to `g1t.sh/new`. It's made in the workspace you're in; to |
| 266 | make one somewhere else, switch workspaces first. |
| 267 | 2. Choose where its code comes from: |
| 268 | - **Start empty**: a new repository on g1t. |
| 269 | - **Import code**: copy a public repository from GitHub or any git host |
| 270 | into a new one on g1t, with every branch and tag (up to 40 MB of |
| 271 | history). |
| 272 | - **Import from GitHub**: import repositories you can reach on GitHub, |
| 273 | private ones too, with every branch and tag and, if you like, their |
| 274 | issues, as work items. See [GitHub](/guides/github/). |
| 275 | 3. Give it a name and say who can see it, then choose **Create project**. |
| 276 | |
| 277 | Pushing a repository that does not exist yet makes one, and with it a |
| 278 | project: |
| 279 | |
| 280 | ```sh |
| 281 | git push https://g1t.sh/acme/my-app.git main |
| 282 | ``` |
| 283 | |
| 284 | ## Sources |
| 285 | |
| 286 | A project's source is a repository hosted on g1t: one you pushed, or one |
| 287 | imported from GitHub or any git host. See |
| 288 | [GitHub](/guides/github/#import-a-repository). |
| 289 | |
| 290 | Coming next: |
| 291 | |
| 292 | - **Several projects on one repository**, each from its own root |
| 293 | directory, with a push building only the projects it touched. |
| 294 | |
| 295 | ## From the API |
| 296 | |
| 297 | Projects keep their repository's routes: `/repos/{workspace}/{project}/…` |
| 298 | reaches the project's repository, and its secrets and variables are the |
| 299 | project's. See the [API reference](/reference/api/). |
| 300 | |
| 301 | What a project is, where it runs and its links have routes of their own, |
| 302 | and actions on the [MCP](/reference/mcp/) `workspace` tool: |
| 303 | |
| 304 | | Route | MCP action | | |
| 305 | | --- | --- | --- | |
| 306 | | `GET /workspaces/{workspace}/projects` | `list_projects` | The workspace's projects you can see. | |
| 307 | | `GET /workspaces/{workspace}/projects/{project}` | `get_project` | One project, with `kind`, `runs`, `production_url`, `setting`, `detected` and `links`. | |
| 308 | | `PATCH /workspaces/{workspace}/projects/{project}` | `update_project` | Changes `kind`, `runs`, `production_url`, `homepage`, `docs_url`, `links`, or its name, description or root directory. Needs `repo:write`. | |
| 309 | |
| 310 | Its g1t.page deployment settings, on the `workflow` tool, are at |
| 311 | `GET` and `PATCH /workspaces/{workspace}/projects/{project}/deployments/settings` |
| 312 | (`get_deployment_settings`, `update_deployment_settings`): `enabled: true` |
| 313 | turns its deployments on. See [Turn on deployments](/guides/deployments/#without-the-site). |
| 314 | |
| 315 | To say an app is deployed by your own pipeline, with its docs: |
| 316 | |
| 317 | ```sh |
| 318 | curl -X PATCH https://api.g1t.sh/workspaces/acme/projects/web \ |
| 319 | -H "Authorization: Bearer $G1T_TOKEN" \ |
| 320 | -H "Content-Type: application/json" \ |
| 321 | -d '{"runs": "elsewhere", "production_url": "https://acme.dev", "docs_url": "https://docs.acme.dev"}' |
| 322 | ``` |