gitoria

6.4 KB

1. // lib/api.hl — THE FUNCTION ROUTES (project.hl wires them): thin wrappers — check the request and the session, call the
2. // topic, answer. The plumbing (JSON / Markdown / plain answers, redirects, the ssh guard, `?next=`) is lib/api-helpers.hl.
3. // /api/repos, /api/repos/:slug the public reads (repos.hl; Accept: text/markdown → the Markdown read view)
4. // /login/callback the login button's return (users.hl)
5. // /settings/connect, /settings/connected connecting a repo to a tickets project (tickets.hl)
6. // /__git/keys, /__git/access what the sshd container asks (sshkeys.hl, repos.hl)
7. // (The git protocol's routes are lib/transport.hl gitTransport.)
8. // A route that WRITES THE SESSION gets the request and the framework's session store BY REFERENCE (`&req`, `&sessions`,
9. // from project.hl): copied into a second call, the session inside `req` would be a copy too and the write would be lost.
10. import { Response } from 'hl:http1'
11. import { randomBytes } from 'hl:crypto'
12. import { NL } from './util.hl'
13. import { userOfLoginCode } from './users.hl'
14. import { repoRows, repoRow, repoBySlug, ownsRepo, mayPush } from './repos.hl'
15. import { slugError, repoDocument, listDocument } from './repos-helpers.hl'
16. import { connectHref, finishConnect } from './tickets.hl'
17. import { keyLine } from './sshkeys.hl'
18. import { fail, wantsMarkdown, markdownReply, textReply, goTo, sshGuard, repoOfRequest, safeNext } from './api-helpers.hl'
20. // ---- the API: reads are public (creating a repo is a web action for now) ------------------------
21. static apiRepos = (route, req) => {
22. if (req.method != 'GET') { return fail(405, 'GET only') }
23. let rows = repoRows()
24. if (wantsMarkdown(req)) { return markdownReply(listDocument(rows)) }
25. return { repos = rows }
26. }
28. static apiRepo = (route, req) => {
29. if (req.method != 'GET') { return fail(405, 'GET only') }
30. let row = repoRow(route.params.slug)
31. if (row == null) { return fail(404, 'no such repository') }
32. if (wantsMarkdown(req)) { return markdownReply(repoDocument(row)) }
33. return row
34. }
36. // ---- THE LOGIN BUTTON'S RETURN (ident README "How apps use ident") ----------------------------
37. // ident sends the browser back with ?ident_code= (and our ?next=); the code is exchanged here (users.hl userOfLoginCode),
38. // the user goes into THIS browser's session (`req.session`, the cookie's — hybriel #11; minted when it brought none),
39. // then → `?next=` (api-helpers.hl safeNext). A FAILED LOGIN is a page (components/loginfailed.hl): the reason is parked
40. // in the session, then → /login/failed.
41. static loginFailed = (&req, &sessions, why) => {
42. let s = req.session
43. let fresh = s == null
44. if (fresh) { s = sessions.mint() }
45. s.data.loginError = why
46. sessions.save(s)
47. let res = new Response('login failed: ' + why, { status = 302 headers = { 'Location' = '/login/failed' 'Cache-Control' = 'no-store' 'Content-Type' = 'text/plain; charset=utf-8' } })
48. if (fresh) { res.headers['Set-Cookie'] = sessions.cookieHeader(s.id) }
49. return res
50. }
52. static loginCallback = (route, &req, &sessions) => {
53. if (req.method != 'GET') { return loginFailed(&req, &sessions, 'GET only') }
54. let q = req.query != null ? req.query : {}
55. let code = q.ident_code
56. if (code == null || code == '') { return loginFailed(&req, &sessions, 'ident sent no login code') }
57. let x = userOfLoginCode(code)
58. if (x.error != null) { return loginFailed(&req, &sessions, x.error) }
59. let s = req.session
60. let fresh = s == null
61. if (fresh) { s = sessions.mint() }
62. s.user = { id = x.user.id }
63. s.data.tag = randomBytes(16)
64. s.data.loginError = null
65. sessions.save(s)
66. let res = new Response('logged in', { status = 302 headers = { 'Location' = safeNext(q.next) 'Cache-Control' = 'no-store' 'Content-Type' = 'text/plain; charset=utf-8' } })
67. if (fresh) { res.headers['Set-Cookie'] = sessions.cookieHeader(s.id) }
68. return res
69. }
71. // ---- CONNECT A REPO TO A TICKETS PROJECT (gitoria#18; tickets.hl, components/settings.hl) ----------------------------
72. // /settings/connect: the owner's click → a fresh nonce parked in the session (bound to the repo) → tickets' /connect.
73. // /settings/connected: tickets' return with ?code&state → tickets.hl finishConnect (nonce, exchange, key stored per
74. // repo) → back to /settings. A failure is a note on the settings page.
75. static connectStart = (route, &req, &sessions) => {
76. if (req.method != 'GET') { return fail(405, 'GET only') }
77. let repo = repoOfRequest(req)
78. if (repo == null) { return fail(404, 'no such repository') }
79. let s = req.session
80. if (s == null || !ownsRepo(repo.slug, s)) { return goTo('/settings') }
81. let nonce = randomBytes(16)
82. s.data.connectState = repo.slug + '.' + nonce
83. s.data.connectNote = null
84. sessions.save(s)
85. return goTo(connectHref(repo.slug, nonce))
86. }
88. static connectBack = (route, &req, &sessions) => {
89. if (req.method != 'GET') { return fail(405, 'GET only') }
90. let repo = repoOfRequest(req)
91. if (repo == null) { return fail(404, 'no such repository') }
92. let s = req.session
93. if (s == null || !ownsRepo(repo.slug, s)) { return goTo('/settings') }
94. let q = req.query != null ? req.query : {}
95. let want = s.data.connectState
96. s.data.connectState = null
97. let note = finishConnect(repo.slug, want, q)
98. s.data.connectNote = note == '' ? null : note
99. sessions.save(s)
100. return goTo('/settings')
101. }
103. // ---- WHAT THE SSHD CONTAINER ASKS (ticket gitoria#7; docker/sshd) — only with the shared secret (api-helpers.hl sshGuard)
104. // GET /__git/keys?type=<ssh-ed25519>&key=<base64> sshd AuthorizedKeysCommand: the authorized_keys line for a known key
105. // (sshkeys.hl keyLine), empty for an unknown one
106. // GET /__git/access?user=<id>&slug=<slug>&write=0|1 gitoria-shell before it starts git: `ok` or 403. Read = every repo (public);
107. // write = the repo's owner only (repos.hl mayPush — the same rule as the token on HTTPS, transport.hl)
108. static gitKeys = (route, req) => {
109. let no = sshGuard(req)
110. if (no != null) { return no }
111. let q = req.query != null ? req.query : {}
112. return textReply(200, keyLine(q.type, q.key))
113. }
115. static gitAccess = (route, req) => {
116. let no = sshGuard(req)
117. if (no != null) { return no }
118. let q = req.query != null ? req.query : {}
119. let slug = q.slug
120. if (slug == null || hlTypeName(slug) != 'String' || slugError(slug) != null) { return textReply(404, 'no such repository' + NL) }
121. let repo = repoBySlug(slug)
122. if (repo == null) { return textReply(404, 'no such repository' + NL) }
123. if (q.write == '1' && !mayPush(q.user, repo)) { return textReply(403, 'only the owner of this repository can push to it' + NL) }
124. return textReply(200, 'ok' + NL)
125. }