Skip to content
Sign up

flagon-io/g1t

public
0
248 linesCodeBlameRaw

Pick any line to see why it is the way it is: the commit, the pull request and issue it came from, and what the agent was thinking.

Initial g1t: services, event bus, intents and attempts1import { createRequestHandler } from "react-router";
2
Merge branch 'worktree-agent-a8385d293d42c913a'3import { identityClient, isNamespaceShaped } from "@g1t/contracts";
4
Fast pages, required checks on the branch, self-hosted runners, honest incidents5import { finishResponse, withRequestPerf } from "../app/lib/perf.server";
Merge branch 'worktree-agent-a8752162fea25f63f' into spend-guardrails6import { gitLimited, pageLimited } from "../app/lib/front-door-limits";
Composer from the workspace's own repositories, and go get from g1t.sh7import { goImport } from "../app/lib/go-get";
Signed-out page cache: a repository's kept page is served only while the repository is still public, so one made private or deleted never shows from any data centre's copy8import { repositoryOfPage, stillPublic } from "../app/lib/public-cache";
Merge branch 'worktree-agent-a8385d293d42c913a'9import { registryWorkspace, servicePath } from "../app/lib/registry-paths";
Fast pages, required checks on the branch, self-hosted runners, honest incidents10
Initial g1t: services, event bus, intents and attempts11const requestHandler = createRequestHandler(
12 () => import("virtual:react-router/server-build"),
13 import.meta.env.MODE,
14);
15
Workspace names and icons, and a component kit for every control16/** An uploaded avatar, by the SHA-256 of its bytes. */
17const AVATAR_PATH = /^\/avatars\/([0-9a-f]{64})$/;
18/** The only types identity stores, having checked each image's bytes. */
19const AVATAR_TYPES = new Set(["image/png", "image/jpeg", "image/webp", "image/gif"]);
Docs as their own app; shared theme package20const DOCS = "https://docs.g1t.sh";
Initial g1t: services, event bus, intents and attempts21
Docs as their own app; shared theme package22/** Where the documentation pages that used to live under /docs are now. */
23const MOVED_DOCS: Record<string, string> = {
24 "/docs": "/quickstart/",
25 "/docs/concepts": "/concepts/overview/",
26 "/docs/authentication": "/guides/authentication/",
27 "/docs/git": "/guides/git/",
g1t is one name: its agent's work, commits and comments show as @g1t, and nobody can claim g1t or g1t-agent28 "/docs/g1t-agents": "/guides/working-with-g1t/",
Docs as their own app; shared theme package29 "/docs/agents": "/guides/bring-your-own-agent/",
30 "/docs/api": "/reference/api/",
Merge branch 'worktree-agent-ab2e39e11a6493412'31 "/docs/api/reference": "/reference/api/",
Docs as their own app; shared theme package32};
docs.g1t.sh, generated OpenAPI with an interactive reference, full footer33
Initial g1t: services, event bus, intents and attempts34export default {
Icons are cached at the edge35 async fetch(request, env, ctx) {
Docs as their own app; shared theme package36 const { pathname } = new URL(request.url);
Initial g1t: services, event bus, intents and attempts37 // Git over HTTPS shares this hostname but belongs to the repos service.
Agents and memory, checks and conflicts, profiles, slug renames, custom domains38 // Its answer goes back to the git client as it is: a repository under a
39 // renamed workspace's old name answers with a 301, which git follows and
40 // must see, so the redirect is never followed here.
npm on g1t.sh: publish and install @<workspace>/<name> with the npm CLI and a g1t token41 // The container registry (`docker login g1t.sh`) and the npm registry
42 // (`g1t.sh/-/npm/`) are the packages
Packages, with a container registry on g1t.sh; workspaces deleted whole and kept 30 days; Members for every member43 // service's, handed over the same way.
Composer from the workspace's own repositories, and go get from g1t.sh44 // `go get g1t.sh/<workspace>/<repo>`: where its code is, from the
45 // address alone, so it costs nothing and caches.
46 const go = request.method === "GET" ? goImport(new URL(request.url)) : null;
47 if (go) {
48 return new Response(go, {
49 headers: { "content-type": "text/html; charset=utf-8", "cache-control": "public, max-age=3600" },
50 });
51 }
Packages, with a container registry on g1t.sh; workspaces deleted whole and kept 30 days; Members for every member52 const service = servicePath(pathname);
53 if (service === "git") {
Merge branch 'worktree-agent-a8752162fea25f63f' into spend-guardrails54 // Per address without credentials, per credential with them
55 // (app/lib/front-door-limits.ts): anonymous clones are not free to
56 // the repository's owner.
57 return (await gitLimited(env, request)) ?? proxyGit(env, request);
Initial g1t: services, event bus, intents and attempts58 }
Packages, with a container registry on g1t.sh; workspaces deleted whole and kept 30 days; Members for every member59 if (service === "packages") {
60 return proxyPackages(env, request);
61 }
Workspace names and icons, and a component kit for every control62 const avatar = AVATAR_PATH.exec(pathname);
63 if (avatar) {
Icons are cached at the edge64 return serveAvatar(env, ctx, request, avatar[1]);
Workspace names and icons, and a component kit for every control65 }
Docs as their own app; shared theme package66 // The documentation is its own site.
67 if (pathname === "/docs" || pathname.startsWith("/docs/")) {
68 const page = pathname.endsWith("/") ? pathname.slice(0, -1) : pathname;
69 const target = MOVED_DOCS[page] ?? "/";
70 return Response.redirect(DOCS + target, 301);
docs.g1t.sh, generated OpenAPI with an interactive reference, full footer71 }
Merge branch 'worktree-agent-a8752162fea25f63f' into spend-guardrails72 // Pages and data requests, limited per address signed out and per
73 // session signed in (app/lib/front-door-limits.ts).
74 const limited = await pageLimited(env, request, pathname);
75 if (limited) return limited;
Fast pages, required checks on the branch, self-hosted runners, honest incidents76 // Every page and data request says where its time went (Server-Timing)
77 // and keeps the reader's D1 bookmarks (app/lib/perf.server.ts).
78 const render = () => withRequestPerf(request, async () => finishResponse(request, await requestHandler(request)));
Signed-out page cache: a repository's kept page is served only while the repository is still public, so one made private or deleted never shows from any data centre's copy79 if (anonymousPage(request, pathname)) return servePublic(env, request, ctx, render);
Fast pages, required checks on the branch, self-hosted runners, honest incidents80 return render();
Initial g1t: services, event bus, intents and attempts81 },
82} satisfies ExportedHandler<Env>;
Workspace names and icons, and a component kit for every control83
84/**
Fast pages, required checks on the branch, self-hosted runners, honest incidents85 * Public pages as someone signed out sees them: the same for every such
86 * visitor, so kept in this data centre's cache. Reserved first segments
87 * (settings, sign-in, invitations and the like) and workspace pages (`-`)
Signed-out page cache: a repository's kept page is served only while the repository is still public, so one made private or deleted never shows from any data centre's copy88 * are never kept; docs/PERFORMANCE.md lists the rules. A repository's kept
89 * page is served only while repos says the repository is still public: one
90 * made private or deleted is never served from any data centre's copy.
Fast pages, required checks on the branch, self-hosted runners, honest incidents91 */
92const PUBLIC_TOP = /^\/(?:|_root\.data|pricing|explore|security|support|policies(?:\/[a-z-]+)?)(?:\.data)?$/;
93const PUBLIC_PROJECT =
Merge email confirmation gate: a code and a link, nothing until confirmed (identity 0036)94 /^\/(?!(?:settings|u|auth|oauth|integrations|new|invite|workspaces|device|verify|confirm-email|login|register|logout|forgot|reset|search|status|avatars|docs)\/)[^/]+\/(?!-\/|-$)[^/]+(?:\/(?:code|commits|issues|pulls|pull\/\d+|issues\/\d+|commit\/[0-9a-f]+|tree\/.+|blob\/.+))?(?:\.data)?$/;
Fast pages, required checks on the branch, self-hosted runners, honest incidents95/** Fresh for this long; then served once more while a new copy is made. */
96const PUBLIC_FRESH_SECONDS = 30;
97const PUBLIC_STALE_SECONDS = 300;
98
99function anonymousPage(request: Request, pathname: string): boolean {
100 if (request.method !== "GET") return false;
101 if (/(?:^|;\s*)g1t_session=/.test(request.headers.get("cookie") ?? "")) return false;
102 return PUBLIC_TOP.test(pathname) || PUBLIC_PROJECT.test(pathname);
103}
104
Signed-out page cache: a repository's kept page is served only while the repository is still public, so one made private or deleted never shows from any data centre's copy105async function servePublic(env: Env, request: Request, ctx: ExecutionContext, render: () => Promise<Response>): Promise<Response> {
Fast pages, required checks on the branch, self-hosted runners, honest incidents106 const cache = (caches as unknown as { default: Cache }).default;
107 const key = new Request(request.url, { method: "GET" });
Signed-out page cache: a repository's kept page is served only while the repository is still public, so one made private or deleted never shows from any data centre's copy108 const repository = PUBLIC_PROJECT.test(new URL(request.url).pathname) ? repositoryOfPage(new URL(request.url).pathname) : null;
109 // Asked alongside the cache, so a hit waits for one indexed read at most.
110 const [cached, visible] = await Promise.all([cache.match(key), repository ? isStillPublic(env, repository) : Promise.resolve(true)]);
111 if (cached && !visible) {
112 ctx.waitUntil(cache.delete(key).then(() => undefined, () => undefined));
113 return render();
114 }
Fast pages, required checks on the branch, self-hosted runners, honest incidents115 const keptAt = Number(cached?.headers.get("x-g1t-kept-at") ?? 0);
116 const age = Math.round((Date.now() - keptAt) / 1000);
117 const refresh = async () => {
118 const fresh = await render();
119 // Only a plain answer for everyone: nothing that sets a cookie or says
120 // it is private.
121 const cacheable =
122 (fresh.status === 200 || fresh.status === 404) &&
123 !fresh.headers.has("set-cookie") &&
124 !/private|no-store/.test(fresh.headers.get("cache-control") ?? "");
125 if (cacheable) {
126 const copy = new Response(fresh.clone().body, fresh);
127 copy.headers.set("x-g1t-kept-at", String(Date.now()));
128 copy.headers.set("cache-control", `public, max-age=${PUBLIC_STALE_SECONDS}`);
129 ctx.waitUntil(cache.put(key, copy));
130 }
131 return fresh;
132 };
133 if (cached && keptAt > 0 && age < PUBLIC_STALE_SECONDS) {
134 if (age >= PUBLIC_FRESH_SECONDS) ctx.waitUntil(refresh().then(() => undefined, () => undefined));
135 const answer = new Response(cached.body, cached);
136 answer.headers.delete("x-g1t-kept-at");
137 answer.headers.delete("cache-control");
138 answer.headers.set("server-timing", `cache;desc="hit, ${age}s old"`);
139 return answer;
140 }
141 return refresh();
142}
143
Signed-out page cache: a repository's kept page is served only while the repository is still public, so one made private or deleted never shows from any data centre's copy144/** Whether the repository is there and public; anything else, including no answer, is no. */
145async function isStillPublic(env: Env, repository: string): Promise<boolean> {
146 try {
147 const answer = await env.REPOS.fetch("https://service/rpc/visibility", {
148 method: "POST",
149 headers: { "content-type": "application/json" },
150 body: JSON.stringify({ paths: [repository] }),
151 });
152 return answer.ok && stillPublic(await answer.json(), repository);
153 } catch {
154 return false;
155 }
156}
157
Fast pages, required checks on the branch, self-hosted runners, honest incidents158/**
Mission control shows where you are needed and what agents landed without you; git answers in about 200ms159 * A git request, answered by the repos service. Its `Server-Timing` header
160 * gains `repos`: how long the answer took to start from here, so the time
161 * between this Worker and the repos service shows beside the steps the
162 * repos service reports.
163 */
164async function proxyGit(env: Env, request: Request): Promise<Response> {
165 const started = Date.now();
166 const answer = await env.REPOS.fetch(new Request(request, { redirect: "manual" }));
167 const response = new Response(answer.body, answer);
168 response.headers.append("server-timing", `repos;dur=${Date.now() - started}`);
169 return response;
170}
171
172/**
Packages, with a container registry on g1t.sh; workspaces deleted whole and kept 30 days; Members for every member173 * A registry request, answered by the packages service as it is: its
174 * redirects (a large blob sent to storage) go back to the client, which
Merge branch 'worktree-agent-a8385d293d42c913a'175 * follows them itself. One that found nothing under a workspace's old name
176 * or an alias staff set (`g1t` for `flagon-io`) is sent to the same path
177 * under the workspace's name: only the not-found answer pays for the lookup.
Packages, with a container registry on g1t.sh; workspaces deleted whole and kept 30 days; Members for every member178 */
179async function proxyPackages(env: Env, request: Request): Promise<Response> {
180 const started = Date.now();
181 const answer = await env.PACKAGES.fetch(new Request(request, { redirect: "manual" }));
Merge branch 'worktree-agent-a8385d293d42c913a'182 const moved = answer.status === 404 ? await registryMoved(env, request) : null;
183 const response = moved ?? new Response(answer.body, answer);
Packages, with a container registry on g1t.sh; workspaces deleted whole and kept 30 days; Members for every member184 response.headers.append("server-timing", `packages;dur=${Date.now() - started}`);
185 return response;
186}
187
Merge branch 'worktree-agent-a8385d293d42c913a'188/** Where a registry request under an alias or old name goes now, or null. */
189async function registryMoved(env: Env, request: Request): Promise<Response | null> {
190 const url = new URL(request.url);
191 const named = registryWorkspace(url.pathname);
192 if (!named || !isNamespaceShaped(named.slug)) return null;
193 let current: string | null = null;
194 try {
195 current = await identityClient(env.IDENTITY).resolveSlug(named.slug);
196 } catch {
197 return null;
198 }
199 if (!current || current === named.slug) return null;
200 const get = request.method === "GET" || request.method === "HEAD";
201 // 308 keeps a publish a PUT, for the clients that follow it.
202 return new Response(null, { status: get ? 301 : 308, headers: { location: named.under(current) + url.search } });
203}
204
Packages, with a container registry on g1t.sh; workspaces deleted whole and kept 30 days; Members for every member205/**
Workspace names and icons, and a component kit for every control206 * An uploaded avatar. Its address is its hash, so it never changes and is
207 * kept for good. It is served as nothing but an image: the stored type,
208 * no sniffing, and a policy that lets nothing in it run.
209 */
Icons are cached at the edge210/**
211 * An uploaded icon. Its address is its content's hash, so it never changes:
212 * each data centre keeps it in its cache after the first view, and storage
213 * is read about once per place, not once per visitor.
214 */
215async function serveAvatar(env: Env, ctx: ExecutionContext, request: Request, hash: string): Promise<Response> {
216 const method = request.method;
Workspace names and icons, and a component kit for every control217 if (method !== "GET" && method !== "HEAD") {
218 return new Response("Method not allowed", { status: 405, headers: { allow: "GET, HEAD" } });
219 }
Agents and memory, checks and conflicts, profiles, slug renames, custom domains220 // The Workers runtime's own cache, which the DOM types do not know.
221 const cache = (caches as unknown as { default: Cache }).default;
Icons are cached at the edge222 const key = new Request(new URL(`/avatars/${hash}`, request.url).toString(), { method: "GET" });
223 const cached = await cache.match(key);
224 if (cached) {
225 return method === "HEAD" ? new Response(null, { headers: cached.headers }) : cached;
226 }
Workspace names and icons, and a component kit for every control227 const { value, metadata } = await env.AVATARS.getWithMetadata<{ contentType?: string }>(hash, {
228 type: "arrayBuffer",
229 cacheTtl: 86400,
230 });
231 const contentType = metadata?.contentType;
232 if (!value || !contentType || !AVATAR_TYPES.has(contentType)) {
233 return new Response("Not found", {
234 status: 404,
235 headers: { "cache-control": "public, max-age=60" },
236 });
237 }
Icons are cached at the edge238 const headers = {
239 "content-type": contentType,
240 "content-length": String(value.byteLength),
241 "cache-control": "public, max-age=31536000, immutable",
242 "x-content-type-options": "nosniff",
243 "content-security-policy": "default-src 'none'; sandbox",
244 "cross-origin-resource-policy": "cross-origin",
245 };
246 ctx.waitUntil(cache.put(key, new Response(value, { headers })));
247 return new Response(method === "HEAD" ? null : value, { headers });
Workspace names and icons, and a component kit for every control248}

This file's history is long; its oldest lines are credited to the oldest commit read.