Adds the database layer for attaching workspace templates to chat projects: the schema, the queries, their authorization, and the audit type. Nothing calls the new queries yet, and the existing create and update handlers pass the new parameters unset. The API, the limit's enforcement, and the agent tools follow in the PRs above. - Attachments live in a `chat_project_templates` table (`project_id`, `template_id`, `created_by`, `created_at`), deleted with the project or the template. `chat_projects` gains `limit_templates` (default `false`), `default_template_id`, `default_template_version_preset_id`, and `default_parameters jsonb`. A project stores a default preset or default parameter values, not both. - `InsertChatProjectTemplates` needs project `update` and `use` on every template. It skips templates that are already attached, and templates outside the project's organization, so an attachment never crosses organizations. `DeleteChatProjectTemplate` needs project `update` and template `read`, and clears the project's default when it detaches the default template. Both checks are in dbauthz. - `GetChatProjectTemplatesByProjectIDs` is authorized through the project, and leaves out deleted, deprecated, and agent-disabled templates. It does not check the caller's access to each template, so callers do that before they expose one. - `UpdateChatProjectByID` changes the template settings only when the request sets them, so an update that omits them cannot write back a stale snapshot. - `AuditableChatProjectTemplates` is the audit form of a project's attached templates, logged as a write to the project. The new `chat_projects` columns are tracked in the project's own audit diff, with the default parameter values masked because they may hold credentials. **NOTE**: the migration adds one table and four columns and changes no existing rows. Existing projects keep unlimited template access. Stack (merge top to bottom): - #32309 👈 - #30754 - #32310 - #30755 - #30756 - #30898
352 lines
12 KiB
Go
352 lines
12 KiB
Go
package coderd
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"errors"
|
|
"fmt"
|
|
"net/http"
|
|
"strings"
|
|
"unicode/utf8"
|
|
|
|
"github.com/google/uuid"
|
|
"github.com/sqlc-dev/pqtype"
|
|
"golang.org/x/xerrors"
|
|
|
|
"github.com/coder/coder/v2/coderd/audit"
|
|
"github.com/coder/coder/v2/coderd/database"
|
|
"github.com/coder/coder/v2/coderd/database/db2sdk"
|
|
"github.com/coder/coder/v2/coderd/database/dbauthz"
|
|
"github.com/coder/coder/v2/coderd/httpapi"
|
|
"github.com/coder/coder/v2/coderd/httpmw"
|
|
"github.com/coder/coder/v2/coderd/rbac"
|
|
"github.com/coder/coder/v2/coderd/rbac/policy"
|
|
"github.com/coder/coder/v2/coderd/util/ptr"
|
|
"github.com/coder/coder/v2/coderd/util/slice"
|
|
"github.com/coder/coder/v2/codersdk"
|
|
)
|
|
|
|
// @Summary List chat projects
|
|
// @ID list-chat-projects
|
|
// @Security CoderSessionToken
|
|
// @Tags Chats
|
|
// @Produce json
|
|
// @Success 200 {array} codersdk.ChatProject
|
|
// @Router /api/experimental/chats/projects [get]
|
|
// @x-apidocgen {"skip": true}
|
|
func (api *API) listChatProjects(rw http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
apiKey := httpmw.APIKey(r)
|
|
|
|
projects, err := api.Database.GetChatProjectsOwnedOrSharedWithUserID(ctx, apiKey.UserID)
|
|
if err != nil {
|
|
httpapi.Write(ctx, rw, http.StatusInternalServerError, codersdk.Response{
|
|
Message: "Failed to list chat projects.",
|
|
Detail: err.Error(),
|
|
})
|
|
return
|
|
}
|
|
httpapi.Write(ctx, rw, http.StatusOK, slice.List(projects, func(project database.ChatProject) codersdk.ChatProject {
|
|
return api.convertChatProject(r, project)
|
|
}))
|
|
}
|
|
|
|
// @Summary Create chat project
|
|
// @ID create-chat-project
|
|
// @Security CoderSessionToken
|
|
// @Tags Chats
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param organization path string true "Organization ID" format(uuid)
|
|
// @Param request body codersdk.CreateChatProjectRequest true "Create chat project request"
|
|
// @Success 201 {object} codersdk.ChatProject
|
|
// @Router /api/experimental/organizations/{organization}/chats/projects [post]
|
|
// @x-apidocgen {"skip": true}
|
|
func (api *API) postChatProject(rw http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
apiKey := httpmw.APIKey(r)
|
|
organization := httpmw.OrganizationParam(r)
|
|
|
|
var req codersdk.CreateChatProjectRequest
|
|
if !httpapi.Read(ctx, rw, r, &req) {
|
|
return
|
|
}
|
|
req.Name = strings.TrimSpace(req.Name)
|
|
req.Icon = strings.TrimSpace(req.Icon)
|
|
if req.Name == "" {
|
|
writeChatProjectFieldError(ctx, rw, "name", "Name is required.")
|
|
return
|
|
}
|
|
if !validateChatProjectFields(ctx, rw, req.Name, req.Description, req.Icon) {
|
|
return
|
|
}
|
|
if !api.Authorize(r, policy.ActionCreate, database.ChatProject{
|
|
OrganizationID: organization.ID,
|
|
OwnerID: apiKey.UserID,
|
|
}.RBACObject()) {
|
|
httpapi.Forbidden(rw)
|
|
return
|
|
}
|
|
|
|
aReq, commitAudit := audit.InitRequest[database.ChatProject](rw, &audit.RequestParams{
|
|
Audit: *api.Auditor.Load(),
|
|
Log: api.Logger,
|
|
Request: r,
|
|
Action: database.AuditActionCreate,
|
|
OrganizationID: organization.ID,
|
|
})
|
|
defer commitAudit()
|
|
|
|
var project database.ChatProject
|
|
err := api.Database.InTx(func(tx database.Store) error {
|
|
// The lock serializes a user's creates so concurrent requests cannot
|
|
// both observe room under the cap.
|
|
if err := tx.AcquireLock(ctx, database.GenLockID("chat-projects-owner:"+apiKey.UserID.String())); err != nil {
|
|
return xerrors.Errorf("lock chat projects: %w", err)
|
|
}
|
|
// The count spans the user's projects in every organization, and the
|
|
// caller was already authorized to create one.
|
|
//nolint:gocritic // See above.
|
|
count, err := tx.CountChatProjectsByOwnerID(dbauthz.AsSystemRestricted(ctx), apiKey.UserID)
|
|
if err != nil {
|
|
return xerrors.Errorf("count chat projects: %w", err)
|
|
}
|
|
if count >= maxChatProjectsPerOwner {
|
|
return errChatProjectLimit
|
|
}
|
|
project, err = tx.InsertChatProject(ctx, database.InsertChatProjectParams{
|
|
ID: uuid.NullUUID{},
|
|
OrganizationID: organization.ID,
|
|
OwnerID: apiKey.UserID,
|
|
Name: req.Name,
|
|
Description: req.Description,
|
|
Icon: req.Icon,
|
|
|
|
LimitTemplates: false,
|
|
DefaultTemplateID: uuid.NullUUID{},
|
|
DefaultTemplateVersionPresetID: uuid.NullUUID{},
|
|
DefaultParameters: pqtype.NullRawMessage{},
|
|
})
|
|
return err
|
|
}, nil)
|
|
if errors.Is(err, errChatProjectLimit) {
|
|
httpapi.Write(ctx, rw, http.StatusConflict, codersdk.Response{
|
|
Message: fmt.Sprintf("You can have at most %d chat projects. Delete a project to create another.", maxChatProjectsPerOwner),
|
|
})
|
|
return
|
|
}
|
|
if err != nil {
|
|
httpapi.Write(ctx, rw, http.StatusInternalServerError, codersdk.Response{
|
|
Message: "Failed to create chat project.",
|
|
Detail: err.Error(),
|
|
})
|
|
return
|
|
}
|
|
aReq.New = project
|
|
httpapi.Write(ctx, rw, http.StatusCreated, api.convertChatProject(r, project))
|
|
}
|
|
|
|
// @Summary Get chat project
|
|
// @ID get-chat-project
|
|
// @Security CoderSessionToken
|
|
// @Tags Chats
|
|
// @Produce json
|
|
// @Param organization path string true "Organization ID" format(uuid)
|
|
// @Param project path string true "Chat project ID" format(uuid)
|
|
// @Success 200 {object} codersdk.ChatProject
|
|
// @Router /api/experimental/organizations/{organization}/chats/projects/{project} [get]
|
|
// @x-apidocgen {"skip": true}
|
|
//
|
|
//nolint:revive // HTTP handler writes to ResponseWriter.
|
|
func (api *API) getChatProject(rw http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
project := httpmw.ChatProjectParam(r)
|
|
if !api.Authorize(r, policy.ActionRead, project.RBACObject()) {
|
|
httpapi.ResourceNotFound(rw)
|
|
return
|
|
}
|
|
httpapi.Write(ctx, rw, http.StatusOK, api.convertChatProject(r, project))
|
|
}
|
|
|
|
// @Summary Update chat project
|
|
// @ID update-chat-project
|
|
// @Security CoderSessionToken
|
|
// @Tags Chats
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param organization path string true "Organization ID" format(uuid)
|
|
// @Param project path string true "Chat project ID" format(uuid)
|
|
// @Param request body codersdk.UpdateChatProjectRequest true "Update chat project request"
|
|
// @Success 200 {object} codersdk.ChatProject
|
|
// @Router /api/experimental/organizations/{organization}/chats/projects/{project} [patch]
|
|
// @x-apidocgen {"skip": true}
|
|
func (api *API) patchChatProject(rw http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
project := httpmw.ChatProjectParam(r)
|
|
if !api.authorizeChatProjectChange(rw, r, policy.ActionUpdate, project.RBACObject()) {
|
|
return
|
|
}
|
|
|
|
aReq, commitAudit := audit.InitRequest[database.ChatProject](rw, &audit.RequestParams{
|
|
Audit: *api.Auditor.Load(),
|
|
Log: api.Logger,
|
|
Request: r,
|
|
Action: database.AuditActionWrite,
|
|
OrganizationID: project.OrganizationID,
|
|
})
|
|
defer commitAudit()
|
|
aReq.Old = project
|
|
|
|
var req codersdk.UpdateChatProjectRequest
|
|
if !httpapi.Read(ctx, rw, r, &req) {
|
|
return
|
|
}
|
|
if req.Name != nil {
|
|
*req.Name = strings.TrimSpace(*req.Name)
|
|
}
|
|
if req.Icon != nil {
|
|
*req.Icon = strings.TrimSpace(*req.Icon)
|
|
}
|
|
if req.Name != nil && *req.Name == "" {
|
|
writeChatProjectFieldError(ctx, rw, "name", "Name must not be blank.")
|
|
return
|
|
}
|
|
name := ptr.NilToDefault(req.Name, project.Name)
|
|
description := ptr.NilToDefault(req.Description, project.Description)
|
|
icon := ptr.NilToDefault(req.Icon, project.Icon)
|
|
if !validateChatProjectFields(ctx, rw, name, description, icon) {
|
|
return
|
|
}
|
|
|
|
updated, err := api.Database.UpdateChatProjectByID(ctx, database.UpdateChatProjectByIDParams{
|
|
ID: project.ID,
|
|
Name: name,
|
|
Description: description,
|
|
Icon: icon,
|
|
|
|
// The template settings are left as they are.
|
|
LimitTemplates: sql.NullBool{},
|
|
UpdateDefaultTemplate: false,
|
|
DefaultTemplateID: uuid.NullUUID{},
|
|
DefaultTemplateVersionPresetID: uuid.NullUUID{},
|
|
DefaultParameters: pqtype.NullRawMessage{},
|
|
})
|
|
if err != nil {
|
|
httpapi.Write(ctx, rw, http.StatusInternalServerError, codersdk.Response{
|
|
Message: "Failed to update chat project.",
|
|
Detail: err.Error(),
|
|
})
|
|
return
|
|
}
|
|
aReq.New = updated
|
|
httpapi.Write(ctx, rw, http.StatusOK, api.convertChatProject(r, updated))
|
|
}
|
|
|
|
// @Summary Delete chat project
|
|
// @ID delete-chat-project
|
|
// @Security CoderSessionToken
|
|
// @Tags Chats
|
|
// @Param organization path string true "Organization ID" format(uuid)
|
|
// @Param project path string true "Chat project ID" format(uuid)
|
|
// @Success 204
|
|
// @Router /api/experimental/organizations/{organization}/chats/projects/{project} [delete]
|
|
// @x-apidocgen {"skip": true}
|
|
func (api *API) deleteChatProject(rw http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
project := httpmw.ChatProjectParam(r)
|
|
if !api.authorizeChatProjectChange(rw, r, policy.ActionDelete, project.RBACObject()) {
|
|
return
|
|
}
|
|
|
|
aReq, commitAudit := audit.InitRequest[database.ChatProject](rw, &audit.RequestParams{
|
|
Audit: *api.Auditor.Load(),
|
|
Log: api.Logger,
|
|
Request: r,
|
|
Action: database.AuditActionDelete,
|
|
OrganizationID: project.OrganizationID,
|
|
})
|
|
defer commitAudit()
|
|
aReq.Old = project
|
|
|
|
err := api.Database.DeleteChatProjectByID(ctx, project.ID)
|
|
if errors.Is(err, sql.ErrNoRows) || httpapi.Is404Error(err) {
|
|
httpapi.ResourceNotFound(rw)
|
|
return
|
|
}
|
|
if err != nil {
|
|
httpapi.Write(ctx, rw, http.StatusInternalServerError, codersdk.Response{
|
|
Message: "Failed to delete chat project.",
|
|
Detail: err.Error(),
|
|
})
|
|
return
|
|
}
|
|
rw.WriteHeader(http.StatusNoContent)
|
|
}
|
|
|
|
func (api *API) authorizeChatProjectChange(rw http.ResponseWriter, r *http.Request, action policy.Action, object rbac.Objecter) bool {
|
|
if !api.Authorize(r, policy.ActionRead, object) {
|
|
httpapi.ResourceNotFound(rw)
|
|
return false
|
|
}
|
|
if !api.Authorize(r, action, object) {
|
|
httpapi.Forbidden(rw)
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
func (api *API) convertChatProject(r *http.Request, project database.ChatProject) codersdk.ChatProject {
|
|
ctx := r.Context()
|
|
subject := httpmw.UserAuthorization(ctx)
|
|
obj := project.RBACObject()
|
|
// Denials are expected here, so this skips api.Authorize, which logs
|
|
// each one as a warning.
|
|
can := func(action policy.Action) bool {
|
|
return api.HTTPAuth.Authorizer.Authorize(ctx, subject, action, obj) == nil
|
|
}
|
|
return db2sdk.ChatProject(project, codersdk.ChatProjectPermissions{
|
|
Update: can(policy.ActionUpdate),
|
|
Delete: can(policy.ActionDelete),
|
|
Share: can(policy.ActionShare),
|
|
})
|
|
}
|
|
|
|
// maxChatProjectsPerOwner caps how many projects one user owns across all
|
|
// organizations.
|
|
const maxChatProjectsPerOwner = 100
|
|
|
|
var errChatProjectLimit = xerrors.New("chat project limit reached")
|
|
|
|
const (
|
|
// The project name is embedded in every generation's system prompt and
|
|
// memory tool descriptions, so it is kept short.
|
|
chatProjectNameMaxChars = 64
|
|
chatProjectDescriptionMaxChars = 1024
|
|
chatProjectIconMaxChars = 256
|
|
)
|
|
|
|
// validateChatProjectFields writes a 400 response and returns false when a
|
|
// sanitized field exceeds its limit.
|
|
func validateChatProjectFields(ctx context.Context, rw http.ResponseWriter, name, description, icon string) bool {
|
|
if utf8.RuneCountInString(name) > chatProjectNameMaxChars {
|
|
writeChatProjectFieldError(ctx, rw, "name", fmt.Sprintf("Name must be at most %d characters.", chatProjectNameMaxChars))
|
|
return false
|
|
}
|
|
if utf8.RuneCountInString(description) > chatProjectDescriptionMaxChars {
|
|
writeChatProjectFieldError(ctx, rw, "description", fmt.Sprintf("Description must be at most %d characters.", chatProjectDescriptionMaxChars))
|
|
return false
|
|
}
|
|
if utf8.RuneCountInString(icon) > chatProjectIconMaxChars {
|
|
writeChatProjectFieldError(ctx, rw, "icon", fmt.Sprintf("Icon must be at most %d characters.", chatProjectIconMaxChars))
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
func writeChatProjectFieldError(ctx context.Context, rw http.ResponseWriter, field, detail string) {
|
|
httpapi.Write(ctx, rw, http.StatusBadRequest, codersdk.Response{
|
|
Message: detail,
|
|
Validations: []codersdk.ValidationError{{Field: field, Detail: detail}},
|
|
})
|
|
}
|