Repository Public
1package api23import (4 "context"5 "encoding/json"6 "time"78 "github.com/google/uuid"910 "clustr.spboucher.ai/mcc/internal/authz"11 "clustr.spboucher.ai/mcc/internal/httpx"12 "clustr.spboucher.ai/mcc/internal/identity"13)1415const deviceCookieTTL = 400 * 24 * time.Hour1617// ── Mapping ────────────────────────────────────────────────────────────────1819func toUser(u identity.User) User {20 return User{Id: u.ID, Handle: u.Handle, DisplayName: u.DisplayName, Role: UserRole(u.Role), Locale: UserLocale(u.Locale),21 CreatedAt: u.CreatedAt, Disabled: u.DisabledAt != nil, DisabledAt: u.DisabledAt}22}2324func (h *identityHandlers) toSession(s identity.Session, current uuid.UUID) Session {25 out := Session{Id: s.ID, Kind: SessionKind(s.Kind), DeviceId: s.DeviceID, PasskeyId: s.PasskeyID, CreatedAt: s.CreatedAt,26 LastSeenAt: s.LastSeenAt, AuthenticatedAt: s.AuthenticatedAt, IdleExpiresAt: s.IdleExpiresAt, AbsoluteExpiresAt: s.AbsoluteExpiresAt,27 StepUpValidUntil: s.AuthenticatedAt.Add(h.Cfg.StepUpWindow), Current: s.ID == current, UserId: &s.User.ID}28 if s.IP != "" {29 out.Ip = &s.IP30 }31 if s.UserAgent != "" {32 out.UserAgent = &s.UserAgent33 }34 return out35}3637func toPasskey(p identity.Passkey) Passkey {38 t := p.Transports39 if t == nil {40 t = []string{}41 }42 return Passkey{Id: p.ID, Label: p.Label, CreatedAt: p.CreatedAt, LastUsedAt: p.LastUsedAt, BackupEligible: p.BackupEligible,43 BackupState: p.BackupState, Transports: t, RevokedAt: p.RevokedAt}44}4546func toDevice(d identity.Device, current uuid.UUID) Device {47 return Device{Id: d.ID, Kind: ClientKind(d.Kind), Label: d.Label, Model: d.Model, OsVersion: d.OSVersion, AppVersion: d.AppVersion,48 CreatedAt: d.CreatedAt, LastSeenAt: d.LastSeenAt, RevokedAt: d.RevokedAt, PushEnabled: d.HasPush, Current: d.ID == current, UserId: &d.UserID}49}5051func toInvitation(i identity.Invitation, now time.Time) Invitation {52 st := i.Status(now)53 if st == "in_progress" {54 st = "exchanged"55 }56 out := Invitation{Id: i.ID, Purpose: InvitationPurpose(i.Purpose), Role: UserRole(i.Role), Note: i.Note, CreatedAt: i.CreatedAt,57 ExpiresAt: i.ExpiresAt, ConsumedAt: i.ConsumedAt, RevokedAt: i.RevokedAt, CompletedAt: i.CompletedAt, FailedAttempts: i.FailedAttempts,58 Status: InvitationStatus(st), TargetUserId: i.TargetUserID, ResultingUserId: i.ResultingUserID, CreatedBy: i.CreatedBy}59 if i.Handle != "" {60 out.Handle = &i.Handle61 }62 if i.DisplayName != "" {63 out.DisplayName = &i.DisplayName64 }65 if i.CreatedByName != "" {66 out.CreatedByDisplayName = &i.CreatedByName67 }68 return out69}7071func toSetupTx(t *identity.SetupTx) InvitationTransaction {72 i := t.Invitation73 out := InvitationTransaction{Purpose: InvitationPurpose(i.Purpose), Role: UserRole(i.Role), ExpiresAt: t.ExpiresAt,74 InviterDisplayName: i.CreatedByName, RequiresExistingAccount: i.Purpose == "link",75 ProfileRequired: i.Purpose == "new_account" && (i.Handle == "" || i.DisplayName == "")}76 if i.Handle != "" {77 out.Handle = &i.Handle78 }79 if i.DisplayName != "" {80 out.DisplayName = &i.DisplayName81 }82 return out83}8485func clientInfo(c *ClientInfo) identity.ClientInfo {86 if c == nil {87 return identity.ClientInfo{Kind: "web"}88 }89 s := func(p *string) string {90 if p == nil {91 return ""92 }93 return *p94 }95 return identity.ClientInfo{Kind: string(c.Kind), DeviceID: c.DeviceId, Label: s(c.Label), Model: s(c.Model), OSVersion: s(c.OsVersion), AppVersion: s(c.AppVersion)}96}9798func asMap(v any) (map[string]any, error) {99 b, err := json.Marshal(v)100 if err != nil {101 return nil, err102 }103 var m map[string]any104 return m, json.Unmarshal(b, &m)105}106107// webDevice fills the device id of a web client from its long-lived device108// cookie: browsers do not get to choose their device id in the request body.109func (h *identityHandlers) webDevice(ctx context.Context, ci *identity.ClientInfo) {110 if ci.Kind != "web" {111 return112 }113 ci.DeviceID = nil114 if id, err := uuid.Parse(h.readCookie(principalFrom(ctx).r, "mcc_device")); err == nil {115 ci.DeviceID = &id116 }117 if ci.Label == "" {118 ci.Label = browserLabel(principalFrom(ctx).r.UserAgent())119 }120}121122// authResult renders a sign-in result and, for web clients, sets the cookies.123func (h *identityHandlers) authResult(ctx context.Context, res *identity.AuthResult) AuthResult {124 out := AuthResult{User: toUser(res.User), Session: h.toSession(res.Session, res.Session.ID), DeviceId: res.Device.ID}125 out.Session.DeviceLabel = &res.Device.Label126 if res.SessionToken != "" {127 h.setCookie(ctx, "mcc_session", res.SessionToken, 0) // session cookie: gone when the browser closes128 h.setCookie(ctx, "mcc_device", res.Device.ID.String(), deviceCookieTTL)129 out.CsrfToken = ptr(h.Identity.CSRFToken(res.SessionToken))130 } else {131 out.AccessToken, out.AccessExpiresAt = &res.AccessToken, &res.AccessExpiresAt132 out.RefreshToken, out.RefreshExpiresAt = &res.RefreshToken, ptr(res.Session.IdleExpiresAt)133 }134 return out135}136137// ── WebAuthn ───────────────────────────────────────────────────────────────138139func (h *identityHandlers) BeginAuthentication(ctx context.Context, _ BeginAuthenticationRequestObject) (BeginAuthenticationResponseObject, error) {140 id, opts, err := h.Identity.BeginAuthentication(ctx)141 if err != nil {142 return nil, err143 }144 pk, err := asMap(opts.Response)145 if err != nil {146 return nil, err147 }148 return BeginAuthentication200JSONResponse{Body: WebAuthnChallenge{ChallengeId: id, PublicKey: pk, ExpiresAt: time.Now().UTC().Add(5 * time.Minute)}}, nil149}150151func (h *identityHandlers) FinishAuthentication(ctx context.Context, req FinishAuthenticationRequestObject) (FinishAuthenticationResponseObject, error) {152 if req.Body == nil {153 return nil, httpx.Validation("Body required.")154 }155 cred, err := json.Marshal(req.Body.Credential)156 if err != nil {157 return nil, httpx.Validation("Invalid credential.")158 }159 ci := clientInfo(&req.Body.Client)160 h.webDevice(ctx, &ci)161 res, err := h.Identity.FinishAuthentication(ctx, req.Body.ChallengeId, cred, ci, h.meta(ctx))162 if err != nil {163 return nil, err164 }165 return FinishAuthentication200JSONResponse{Body: h.authResult(ctx, res)}, nil166}167168func (h *identityHandlers) BeginStepUp(ctx context.Context, _ BeginStepUpRequestObject) (BeginStepUpResponseObject, error) {169 id, opts, err := h.Identity.BeginStepUp(ctx, principalFrom(ctx).Session)170 if err != nil {171 return nil, err172 }173 pk, err := asMap(opts.Response)174 if err != nil {175 return nil, err176 }177 return BeginStepUp200JSONResponse{Body: WebAuthnChallenge{ChallengeId: id, PublicKey: pk, ExpiresAt: time.Now().UTC().Add(5 * time.Minute)}}, nil178}179180func (h *identityHandlers) FinishStepUp(ctx context.Context, req FinishStepUpRequestObject) (FinishStepUpResponseObject, error) {181 if req.Body == nil {182 return nil, httpx.Validation("Body required.")183 }184 cred, _ := json.Marshal(req.Body.Credential)185 at, err := h.Identity.FinishStepUp(ctx, principalFrom(ctx).Session, req.Body.ChallengeId, cred, h.meta(ctx))186 if err != nil {187 return nil, err188 }189 return FinishStepUp200JSONResponse{Body: StepUpResult{AuthenticatedAt: at, StepUpValidUntil: at.Add(h.Cfg.StepUpWindow)}}, nil190}191192// BeginRegistration serves two flows: completing an invitation (setup193// transaction, no session) and adding a passkey to the signed-in account194// (session + step-up, enforced by the middleware).195func (h *identityHandlers) BeginRegistration(ctx context.Context, _ BeginRegistrationRequestObject) (BeginRegistrationResponseObject, error) {196 p := principalFrom(ctx)197 var (198 id uuid.UUID199 pk map[string]any200 err error201 )202 if p.Session != nil {203 cid, opts, e := h.Identity.BeginAddPasskey(ctx, p.Session)204 if e != nil {205 return nil, e206 }207 id = cid208 pk, err = asMap(opts.Response)209 } else {210 cid, opts, e := h.Identity.BeginSetupRegistration(ctx, p.SetupToken)211 if e != nil {212 return nil, e213 }214 id = cid215 pk, err = asMap(opts.Response)216 }217 if err != nil {218 return nil, err219 }220 return BeginRegistration200JSONResponse{Body: WebAuthnChallenge{ChallengeId: id, PublicKey: pk, ExpiresAt: time.Now().UTC().Add(5 * time.Minute)}}, nil221}222223func (h *identityHandlers) FinishRegistration(ctx context.Context, req FinishRegistrationRequestObject) (FinishRegistrationResponseObject, error) {224 if req.Body == nil {225 return nil, httpx.Validation("Body required.")226 }227 p := principalFrom(ctx)228 cred, _ := json.Marshal(req.Body.Credential)229 label := ""230 if req.Body.Label != nil {231 label = *req.Body.Label232 }233 if p.Session != nil {234 pk, err := h.Identity.FinishAddPasskey(ctx, p.Session, req.Body.ChallengeId, cred, label, h.meta(ctx))235 if err != nil {236 return nil, err237 }238 return FinishRegistration200JSONResponse{Body: RegistrationResult{Passkey: toPasskey(*pk)}}, nil239 }240 ci := clientInfo(req.Body.Client)241 h.webDevice(ctx, &ci)242 res, err := h.Identity.FinishSetupRegistration(ctx, p.SetupToken, req.Body.ChallengeId, cred, ci, label, h.meta(ctx))243 if err != nil {244 return nil, err245 }246 h.setCookie(ctx, "mcc_setup", "", 0)247 keys, err := h.Identity.ListPasskeys(ctx, res.User.ID)248 if err != nil || len(keys) == 0 {249 return nil, httpx.ErrUnavailable250 }251 auth := h.authResult(ctx, res)252 return FinishRegistration200JSONResponse{Body: RegistrationResult{Passkey: toPasskey(keys[len(keys)-1]), Auth: &auth}}, nil253}254255func (h *identityHandlers) RefreshSession(ctx context.Context, req RefreshSessionRequestObject) (RefreshSessionResponseObject, error) {256 if req.Body == nil {257 return nil, httpx.Validation("Body required.")258 }259 res, err := h.Identity.Refresh(ctx, req.Body.RefreshToken, h.meta(ctx))260 if err != nil {261 return nil, err262 }263 return RefreshSession200JSONResponse{Body: TokenPair{AccessToken: res.AccessToken, AccessExpiresAt: res.AccessExpiresAt,264 RefreshToken: res.RefreshToken, RefreshExpiresAt: res.Session.IdleExpiresAt}}, nil265}266267func (h *identityHandlers) Logout(ctx context.Context, _ LogoutRequestObject) (LogoutResponseObject, error) {268 p := principalFrom(ctx)269 if err := h.Identity.RevokeSession(ctx, p.Session, p.Session.ID, "logout", h.meta(ctx)); err != nil && err != httpx.ErrNotFound {270 return nil, err271 }272 if p.SessionToken != "" {273 h.setCookie(ctx, "mcc_session", "", 0)274 }275 return Logout204Response{}, nil276}277278// ── /me ────────────────────────────────────────────────────────────────────279280func (h *identityHandlers) GetMe(ctx context.Context, _ GetMeRequestObject) (GetMeResponseObject, error) {281 p := principalFrom(ctx)282 grants, err := h.loadGrants(ctx)283 if err != nil {284 return nil, err285 }286 perms := []string{}287 for _, perm := range authz.Effective(p.Session.Subject(), grants) {288 perms = append(perms, string(perm))289 }290 me := Me{User: toUser(p.Session.User), Session: h.toSession(*p.Session, p.Session.ID), Permissions: perms}291 if p.SessionToken != "" {292 me.CsrfToken = ptr(h.Identity.CSRFToken(p.SessionToken))293 }294 return GetMe200JSONResponse{Body: me}, nil295}296297func (h *identityHandlers) UpdateMe(ctx context.Context, req UpdateMeRequestObject) (UpdateMeResponseObject, error) {298 if req.Body == nil {299 return nil, httpx.Validation("Body required.")300 }301 var locale *string302 if req.Body.Locale != nil {303 locale = ptr(string(*req.Body.Locale))304 }305 u, err := h.Identity.UpdateProfile(ctx, principalFrom(ctx).Session, req.Body.DisplayName, locale, h.meta(ctx))306 if err != nil {307 return nil, err308 }309 return UpdateMe200JSONResponse{Body: toUser(u)}, nil310}311312func (h *identityHandlers) ListMyPasskeys(ctx context.Context, _ ListMyPasskeysRequestObject) (ListMyPasskeysResponseObject, error) {313 keys, err := h.Identity.ListPasskeys(ctx, principalFrom(ctx).Session.User.ID)314 if err != nil {315 return nil, err316 }317 out := PasskeyList{Items: make([]Passkey, 0, len(keys))}318 for _, k := range keys {319 out.Items = append(out.Items, toPasskey(k))320 }321 return ListMyPasskeys200JSONResponse{Body: out}, nil322}323324func (h *identityHandlers) UpdateMyPasskey(ctx context.Context, req UpdateMyPasskeyRequestObject) (UpdateMyPasskeyResponseObject, error) {325 if req.Body == nil {326 return nil, httpx.Validation("Body required.")327 }328 sess := principalFrom(ctx).Session329 if err := h.Identity.RenamePasskey(ctx, sess, req.Id, req.Body.Label); err != nil {330 return nil, err331 }332 keys, err := h.Identity.ListPasskeys(ctx, sess.User.ID)333 if err != nil {334 return nil, err335 }336 for _, k := range keys {337 if k.ID == req.Id {338 return UpdateMyPasskey200JSONResponse{Body: toPasskey(k)}, nil339 }340 }341 return nil, httpx.ErrNotFound342}343344func (h *identityHandlers) DeleteMyPasskey(ctx context.Context, req DeleteMyPasskeyRequestObject) (DeleteMyPasskeyResponseObject, error) {345 sess := principalFrom(ctx).Session346 if err := h.Identity.RevokePasskey(ctx, sess, sess.User.ID, req.Id, false, h.meta(ctx)); err != nil {347 return nil, err348 }349 return DeleteMyPasskey204Response{}, nil350}351352func (h *identityHandlers) ListMySessions(ctx context.Context, _ ListMySessionsRequestObject) (ListMySessionsResponseObject, error) {353 sess := principalFrom(ctx).Session354 list, err := h.Identity.ListSessions(ctx, sess.User.ID)355 if err != nil {356 return nil, err357 }358 out := SessionList{Items: make([]Session, 0, len(list))}359 for _, s := range list {360 out.Items = append(out.Items, h.toSession(s, sess.ID))361 }362 return ListMySessions200JSONResponse{Body: out}, nil363}364365func (h *identityHandlers) RevokeMySession(ctx context.Context, req RevokeMySessionRequestObject) (RevokeMySessionResponseObject, error) {366 sess := principalFrom(ctx).Session367 owner, err := h.Identity.SessionOwner(ctx, req.Id)368 if err != nil || owner != sess.User.ID {369 return nil, httpx.ErrNotFound // never reveal another user's session ids370 }371 if err := h.Identity.RevokeSession(ctx, sess, req.Id, "revoked_by_user", h.meta(ctx)); err != nil {372 return nil, err373 }374 return RevokeMySession204Response{}, nil375}376377func (h *identityHandlers) ListMyDevices(ctx context.Context, _ ListMyDevicesRequestObject) (ListMyDevicesResponseObject, error) {378 sess := principalFrom(ctx).Session379 list, err := h.Identity.ListDevices(ctx, sess.User.ID)380 if err != nil {381 return nil, err382 }383 out := DeviceList{Items: make([]Device, 0, len(list))}384 for _, d := range list {385 out.Items = append(out.Items, toDevice(d, sess.DeviceID))386 }387 return ListMyDevices200JSONResponse{Body: out}, nil388}389390func (h *identityHandlers) RevokeMyDevice(ctx context.Context, req RevokeMyDeviceRequestObject) (RevokeMyDeviceResponseObject, error) {391 sess := principalFrom(ctx).Session392 owner, err := h.Identity.DeviceOwner(ctx, req.Id)393 if err != nil || owner != sess.User.ID {394 return nil, httpx.ErrNotFound395 }396 if err := h.Identity.RevokeDevice(ctx, sess, req.Id, h.meta(ctx)); err != nil {397 return nil, err398 }399 return RevokeMyDevice204Response{}, nil400}401402func (h *identityHandlers) PutMyPushToken(ctx context.Context, req PutMyPushTokenRequestObject) (PutMyPushTokenResponseObject, error) {403 if req.Body == nil {404 return nil, httpx.Validation("Body required.")405 }406 sess := principalFrom(ctx).Session407 if err := h.Identity.SetPushToken(ctx, sess, req.Body.Token, string(req.Body.Environment)); err != nil {408 return nil, err409 }410 list, err := h.Identity.ListDevices(ctx, sess.User.ID)411 if err != nil {412 return nil, err413 }414 for _, d := range list {415 if d.ID == sess.DeviceID {416 out := toDevice(d, sess.DeviceID)417 out.PushEnv = ptr(DevicePushEnv(req.Body.Environment))418 return PutMyPushToken200JSONResponse{Body: out}, nil419 }420 }421 return nil, httpx.ErrNotFound422}423424var permissionDescriptions = map[authz.Permission]string{425 authz.ClusterRead: "View the cluster overview and trends.", authz.NodesRead: "View nodes, their metrics and processes.",426 authz.NodesPrivateRead: "View private node details (IP addresses, serial numbers).", authz.NodesWrite: "Register, edit and retire nodes.",427 authz.LogsRead: "Read service logs and action output.", authz.ServicesRead: "View services.", authz.ModelsRead: "View inference servers and models.",428 authz.JobsRead: "View jobs.", authz.JobsSubmit: "Submit, schedule and cancel jobs.", authz.AlertsRead: "View alerts and incidents.",429 authz.AlertsAck: "Acknowledge, resolve and comment alerts and incidents.", authz.AlertsManage: "Manage alert rules and silences.",430 authz.MaintenanceRead: "View the maintenance calendar and notes.", authz.MaintenanceWrite: "Plan maintenance windows and write maintenance notes.",431 authz.ActionsRead: "View actions and their results.", authz.ActionsRunLow: "Run low-criticality actions (diagnostics, inventory refresh).",432 authz.ActionsRunMedium: "Run medium-criticality actions (service restart, maintenance mode).",433 authz.ActionsRunHigh: "Run high-criticality actions (service stop, model server control, deployments).",434 authz.ActionsRunCritical: "Run critical actions (reboot, shutdown). Owner only.", authz.ActionsApprove: "Approve or reject actions requested by someone else.",435 authz.AuditRead: "Read the audit log.", authz.AuditExport: "Export the audit log.", authz.UsersManage: "Manage users, their passkeys, sessions, devices and policy grants.",436 authz.InvitationsManage: "Create and revoke invitations.", authz.AgentsManage: "Enroll and revoke agents.", authz.SettingsManage: "Change settings and integrations.",437}438439func (h *identityHandlers) GetPermissionCatalog(ctx context.Context, _ GetPermissionCatalogRequestObject) (GetPermissionCatalogResponseObject, error) {440 stepUp := map[string]bool{}441 for _, op := range Operations {442 if op.StepUp && op.Permission != "" {443 stepUp[op.Permission] = true444 }445 }446 out := PermissionCatalog{}447 for _, p := range authz.All {448 out.Permissions = append(out.Permissions, PermissionInfo{Name: string(p), Description: permissionDescriptions[p],449 StepUp: stepUp[string(p)] || p == authz.ActionsRunHigh || p == authz.ActionsRunCritical})450 }451 for _, r := range []authz.Role{authz.Owner, authz.Admin, authz.Operator, authz.Viewer} {452 rp := RolePermissions{Role: UserRole(r), Permissions: []string{}}453 for _, p := range authz.RoleDefaults(r) {454 rp.Permissions = append(rp.Permissions, string(p))455 }456 out.RoleDefaults = append(out.RoleDefaults, rp)457 }458 return GetPermissionCatalog200JSONResponse{Body: out}, nil459}460461// ── Invitations ────────────────────────────────────────────────────────────462463func (h *identityHandlers) CreateInvitation(ctx context.Context, req CreateInvitationRequestObject) (CreateInvitationResponseObject, error) {464 if req.Body == nil {465 return nil, httpx.Validation("Body required.")466 }467 b := req.Body468 p := identity.InvitationParams{Role: authz.Role(b.Role), TargetUserID: b.TargetUserId}469 if b.TargetUserId != nil {470 p.Purpose = "link"471 }472 if b.Handle != nil {473 p.Handle = *b.Handle474 }475 if b.DisplayName != nil {476 p.DisplayName = *b.DisplayName477 }478 if b.Note != nil {479 p.Note = *b.Note480 }481 if b.TtlMinutes != nil {482 p.TTL = time.Duration(*b.TtlMinutes) * time.Minute483 if p.TTL <= 0 {484 return nil, httpx.Validation("ttl_minutes must be between 1 and 1440.")485 }486 }487 inv, token, err := h.Identity.CreateInvitation(ctx, principalFrom(ctx).Session, p, h.meta(ctx))488 if err != nil {489 return nil, err490 }491 // The token travels in the URL fragment: it is never sent to a server in a request line, a Referer header or a log.492 return CreateInvitation201JSONResponse{Body: InvitationCreated{Invitation: toInvitation(inv, time.Now().UTC()), Token: token,493 SetupUrl: h.Cfg.PublicOrigin + "/setup#" + token}}, nil494}495496func (h *identityHandlers) ListInvitations(ctx context.Context, req ListInvitationsRequestObject) (ListInvitationsResponseObject, error) {497 list, err := h.Identity.ListInvitations(ctx)498 if err != nil {499 return nil, err500 }501 now := time.Now().UTC()502 out := InvitationList{Items: []Invitation{}}503 for _, i := range list {504 inv := toInvitation(i, now)505 if req.Params.Status != nil && inv.Status != *req.Params.Status {506 continue507 }508 out.Items = append(out.Items, inv)509 }510 return ListInvitations200JSONResponse{Body: out}, nil511}512513func (h *identityHandlers) RevokeInvitation(ctx context.Context, req RevokeInvitationRequestObject) (RevokeInvitationResponseObject, error) {514 if err := h.Identity.RevokeInvitation(ctx, principalFrom(ctx).Session, req.Id, h.meta(ctx)); err != nil {515 return nil, err516 }517 return RevokeInvitation204Response{}, nil518}519520func (h *identityHandlers) ExchangeInvitation(ctx context.Context, req ExchangeInvitationRequestObject) (ExchangeInvitationResponseObject, error) {521 if req.Body == nil {522 return nil, httpx.Validation("Body required.")523 }524 stx, txToken, err := h.Identity.ExchangeInvitation(ctx, req.Body.Token, h.meta(ctx))525 if err != nil {526 return nil, err527 }528 out := toSetupTx(stx)529 if req.Body.Client != nil && req.Body.Client.Kind != ClientKindWeb {530 out.TransactionToken = &txToken // native apps keep it in memory and send it as X-MCC-Setup-Transaction531 } else {532 h.setCookie(ctx, "mcc_setup", txToken, time.Until(stx.ExpiresAt))533 }534 return ExchangeInvitation200JSONResponse{Body: out}, nil535}536537func (h *identityHandlers) GetInvitationTransaction(ctx context.Context, _ GetInvitationTransactionRequestObject) (GetInvitationTransactionResponseObject, error) {538 stx, err := h.Identity.SetupTransaction(ctx, principalFrom(ctx).SetupToken)539 if err != nil {540 return nil, err541 }542 return GetInvitationTransaction200JSONResponse{Body: toSetupTx(stx)}, nil543}544545func (h *identityHandlers) SetInvitationProfile(ctx context.Context, req SetInvitationProfileRequestObject) (SetInvitationProfileResponseObject, error) {546 if req.Body == nil {547 return nil, httpx.Validation("Body required.")548 }549 stx, err := h.Identity.SetSetupProfile(ctx, principalFrom(ctx).SetupToken, req.Body.Handle, req.Body.DisplayName)550 if err != nil {551 return nil, err552 }553 return SetInvitationProfile200JSONResponse{Body: toSetupTx(stx)}, nil554}555556func (h *identityHandlers) AbandonInvitationTransaction(ctx context.Context, _ AbandonInvitationTransactionRequestObject) (AbandonInvitationTransactionResponseObject, error) {557 p := principalFrom(ctx)558 if err := h.Identity.AbandonSetup(ctx, p.SetupToken, h.meta(ctx)); err != nil {559 return nil, err560 }561 h.setCookie(ctx, "mcc_setup", "", 0)562 return AbandonInvitationTransaction204Response{}, nil563}564565func (h *identityHandlers) LinkInvitationToAccount(ctx context.Context, req LinkInvitationToAccountRequestObject) (LinkInvitationToAccountResponseObject, error) {566 if req.Body == nil {567 return nil, httpx.Validation("Body required.")568 }569 p := principalFrom(ctx)570 u, err := h.Identity.LinkSetup(ctx, p.SetupToken, p.Session, req.Body.Confirm, h.meta(ctx))571 if err != nil {572 return nil, err573 }574 h.setCookie(ctx, "mcc_setup", "", 0)575 return LinkInvitationToAccount200JSONResponse{Body: InvitationLinkResult{User: toUser(u)}}, nil576}577578// ── Meta ───────────────────────────────────────────────────────────────────579580func (h *identityHandlers) GetLiveness(context.Context, GetLivenessRequestObject) (GetLivenessResponseObject, error) {581 return GetLiveness200JSONResponse{Body: HealthStatus{Status: HealthStatusStatusOk}}, nil582}583584func (h *identityHandlers) GetReadiness(ctx context.Context, _ GetReadinessRequestObject) (GetReadinessResponseObject, error) {585 c, cancel := context.WithTimeout(ctx, 2*time.Second)586 defer cancel()587 if err := h.Pool.Ping(c); err != nil {588 return nil, httpx.ErrUnavailable589 }590 return GetReadiness200JSONResponse{Body: HealthStatus{Status: HealthStatusStatusOk}}, nil591}592593func (h *identityHandlers) GetVersion(context.Context, GetVersionRequestObject) (GetVersionResponseObject, error) {594 v := VersionInfo{ApiVersion: "v1", Version: Version}595 if Commit != "" {596 v.Commit = &Commit597 }598 if t, err := time.Parse(time.RFC3339, BuiltAt); err == nil {599 v.BuiltAt = &t600 }601 return GetVersion200JSONResponse{Body: v}, nil602}603