G4: a page that makes 3D models, and ctl 3d

/3d beside /images, while some model makes meshes: a picture chosen, the
job asked for through the same path an API client's takes, its progress
shown (waiting for the card, n ahead; making it, the node and percent),
and the mesh in a viewer — model-viewer 4.4.0 (Apache 2.0, with three.js
and lit), served from the gateway since the page's policy loads scripts
from nowhere else — with a download and the model's licence. The mesh is
served to its owner from /3d/jobs/{id}/file; another project's person is
told there is no such job.

A job made from the portal acted for a key that does not exist: the
worker now rebuilds a session's principal from the account that made it,
while it is active and still in the project the job is charged to.

ctl 3d list|get|cancel, over /api/v1/client-jobs (/api/v1/jobs is the
control plane's own work, which ctl jobs shows).

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Ilker ManapandClaude Opus 5.5 committed 2026-10-10 19:16:20 +02:00
1 parent dfc2f0bf15
commit 2f54780802
30 files changed
+2323 -15

No files matched your search

+176
View File
@@ -29,6 +29,9 @@
{
"name": "capacity"
},
{
"name": "client-jobs"
},
{
"name": "eval"
},
@@ -280,6 +283,133 @@
}
}
},
"/api/v1/client-jobs": {
"get": {
"operationId": "getClientJobs",
"summary": "Jobs clients asked for — 3D models — of every owner, newest first",
"tags": [
"client-jobs"
],
"parameters": [
{
"name": "status",
"in": "query",
"description": "Only jobs in this status: queued, running, cancelling, completed, failed, cancelled, expired.",
"schema": {
"type": "string"
}
},
{
"name": "limit",
"in": "query",
"description": "The most jobs to answer with; 50 when absent.",
"schema": {
"type": "integer"
}
}
],
"responses": {
"200": {
"description": "OK",
"content": {
"application/json": {
"schema": {
"type": "array",
"items": {
"$ref": "#/components/schemas/JobView"
}
}
}
}
},
"401": {
"$ref": "#/components/responses/Unauthorized"
},
"default": {
"$ref": "#/components/responses/Error"
}
}
}
},
"/api/v1/client-jobs/{id}": {
"get": {
"operationId": "getClientJobsId",
"summary": "One job a client asked for",
"tags": [
"client-jobs"
],
"parameters": [
{
"name": "id",
"in": "path",
"required": true,
"description": "The job's ID, job_….",
"schema": {
"type": "string"
}
}
],
"responses": {
"200": {
"description": "OK",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/JobView"
}
}
}
},
"401": {
"$ref": "#/components/responses/Unauthorized"
},
"default": {
"$ref": "#/components/responses/Error"
}
}
}
},
"/api/v1/client-jobs/{id}/cancel": {
"post": {
"operationId": "postClientJobsIdCancel",
"summary": "Stop a job, in the engine's queue too",
"tags": [
"client-jobs"
],
"parameters": [
{
"name": "id",
"in": "path",
"required": true,
"description": "The job's ID, job_….",
"schema": {
"type": "string"
}
},
{
"$ref": "#/components/parameters/Actor"
}
],
"responses": {
"200": {
"description": "OK",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/JobView"
}
}
}
},
"401": {
"$ref": "#/components/responses/Unauthorized"
},
"default": {
"$ref": "#/components/responses/Error"
}
}
}
},
"/api/v1/eval/runs": {
"get": {
"operationId": "getEvalRuns",
@@ -6016,6 +6146,52 @@
}
}
},
"JobView": {
"type": "object",
"description": "JobView is one job.",
"properties": {
"id": {
"type": "string"
},
"owner": {
"type": "string"
},
"key_id": {
"type": "string"
},
"endpoint": {
"type": "string"
},
"model": {
"type": "string"
},
"status": {
"type": "string"
},
"progress": {
"description": "Any JSON value."
},
"output_file_id": {
"type": "string"
},
"content_type": {
"type": "string"
},
"error": {
"type": "string"
},
"created_at": {
"type": "string",
"format": "date-time"
},
"started_at": {
"type": "string"
},
"finished_at": {
"type": "string"
}
}
},
"JudgeAskRequest": {
"type": "object",
"description": "JudgeAskRequest is a text to have a judge read.",
+1
View File
@@ -178,6 +178,7 @@ func newCtlCmd() *cobra.Command {
newRetryCmd(client),
newUpgradeCmd(client),
newJobsCmd(client, &asJSON),
newMeshJobsCmd(client, &asJSON),
newEngineCheckCmd(),
newEngineBuildCmd(client),
newToolCheckCmd(client),
+130
View File
@@ -0,0 +1,130 @@
package cli
import (
"encoding/json"
"fmt"
"net/url"
"time"
"github.com/spf13/cobra"
"gitea.mynodes.xyz/ilker/llmgw/internal/control/adminapi"
)
// newMeshJobsCmd is the 3D models clients asked for, as jobs: every owner's,
// what each is doing, and a way to stop one. (ctl jobs is the control
// plane's own work, serving and updating models.)
func newMeshJobsCmd(client func() *ctlClient, asJSON *bool) *cobra.Command {
cmd := &cobra.Command{
Use: "3d",
Short: "3D models clients asked for: the jobs, how far along each is, and stopping one",
}
var status string
var limit int
list := &cobra.Command{
Use: "list",
Short: "Every owner's 3D jobs, newest first",
Args: cobra.NoArgs,
RunE: func(cmd *cobra.Command, _ []string) error {
q := url.Values{}
if status != "" {
q.Set("status", status)
}
if limit > 0 {
q.Set("limit", fmt.Sprint(limit))
}
var jobs []adminapi.JobView
if err := client().get(cmd.Context(), "/api/v1/client-jobs?"+q.Encode(), &jobs); err != nil {
return err
}
if *asJSON {
return emitJSON(jobs)
}
if len(jobs) == 0 {
fmt.Fprintln(cmd.OutOrStdout(), "no 3D jobs")
return nil
}
w := tabTo(cmd.OutOrStdout())
fmt.Fprintln(w, "JOB\tMODEL\tSTATUS\tPROGRESS\tOWNER\tASKED")
for _, j := range jobs {
fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s ago\n", j.ID, j.Model, j.Status, progressText(j),
j.Owner, time.Since(j.CreatedAt).Round(time.Second))
}
return w.Flush()
},
}
list.Flags().StringVar(&status, "status", "", "only jobs in this status: queued, running, completed, failed…")
list.Flags().IntVar(&limit, "limit", 0, "the most jobs to show (50)")
get := &cobra.Command{
Use: "get JOB",
Short: "One 3D job: its status, progress, result or error",
Args: cobra.ExactArgs(1),
RunE: func(cmd *cobra.Command, args []string) error {
var j adminapi.JobView
if err := client().get(cmd.Context(), "/api/v1/client-jobs/"+url.PathEscape(args[0]), &j); err != nil {
return err
}
if *asJSON {
return emitJSON(j)
}
out := cmd.OutOrStdout()
fmt.Fprintf(out, "job %s\nmodel %s\nstatus %s\n", j.ID, j.Model, j.Status)
if p := progressText(j); p != "" {
fmt.Fprintf(out, "progress %s\n", p)
}
fmt.Fprintf(out, "owner %s (key %s)\nasked %s\n", j.Owner, j.KeyID, j.CreatedAt.UTC().Format(time.RFC3339))
if j.FinishedAt != nil && j.StartedAt != nil {
fmt.Fprintf(out, "took %s\n", j.FinishedAt.Sub(*j.StartedAt).Round(time.Second))
}
if j.OutputFileID != "" {
fmt.Fprintf(out, "result %s (%s)\n", j.OutputFileID, j.ContentType)
}
if j.Error != "" {
fmt.Fprintf(out, "error %s\n", j.Error)
}
return nil
},
}
cancel := &cobra.Command{
Use: "cancel JOB",
Short: "Stop a 3D job, in the engine's queue too",
Args: cobra.ExactArgs(1),
RunE: func(cmd *cobra.Command, args []string) error {
var j adminapi.JobView
if err := client().post(cmd.Context(), "/api/v1/client-jobs/"+url.PathEscape(args[0])+"/cancel", nil, &j); err != nil {
return err
}
fmt.Fprintf(cmd.OutOrStdout(), "%s is %s\n", j.ID, j.Status)
return nil
},
}
cmd.AddCommand(list, get, cancel)
return cmd
}
// progressText is a job's progress as a person reads it.
func progressText(j adminapi.JobView) string {
if len(j.Progress) == 0 {
return ""
}
var p struct {
State string `json:"state"`
Ahead int `json:"ahead"`
NodeClass string `json:"node_class"`
Step int `json:"step"`
Steps int `json:"steps"`
Percent int `json:"percent"`
}
if json.Unmarshal(j.Progress, &p) != nil {
return ""
}
switch {
case p.State == "queued" && p.Ahead > 0:
return fmt.Sprintf("queued, %d ahead", p.Ahead)
case p.State == "running" && p.Steps > 0:
return fmt.Sprintf("running %d%%, %s step %d/%d", p.Percent, p.NodeClass, p.Step, p.Steps)
case p.State == "running" && p.NodeClass != "":
return "running " + p.NodeClass
}
return p.State
}
+3
View File
@@ -203,6 +203,9 @@ func (a *API) Register(mux Mux) {
mux.HandleFunc("POST /api/v1/models/{name}/origin", a.setOrigin)
mux.HandleFunc("GET /api/v1/plan", a.planModel)
mux.HandleFunc("POST /api/v1/metrics/range", a.metricsBatch)
mux.HandleFunc("GET /api/v1/client-jobs", a.listJobs)
mux.HandleFunc("GET /api/v1/client-jobs/{id}", a.getJob)
mux.HandleFunc("POST /api/v1/client-jobs/{id}/cancel", a.cancelJob)
mux.HandleFunc("GET /api/v1/requests/{id}", a.request)
mux.HandleFunc("GET /api/v1/requests/{id}/body", a.requestBody)
mux.HandleFunc("POST /api/v1/requests/{id}/replay", a.replayRequest)
+115
View File
@@ -0,0 +1,115 @@
package adminapi
import (
"context"
"encoding/json"
"errors"
"net/http"
"strconv"
"time"
"gitea.mynodes.xyz/ilker/llmgw/internal/store"
)
// Jobs — 3D models asked for and asked after — as an operator sees them:
// every owner's, which a client sees only of its own.
// jobStore is what jobs need of the store; asked of the usage source by
// type assertion, as requestFinder is.
type jobStore interface {
AllJobs(ctx context.Context, status string, limit int) ([]store.Job, error)
JobByID(ctx context.Context, id string) (store.Job, error)
CancelJob(ctx context.Context, id string, now time.Time) (store.Job, error)
}
// JobView is one job.
type JobView struct {
ID string `json:"id"`
Owner string `json:"owner"`
KeyID string `json:"key_id"`
Endpoint string `json:"endpoint"`
Model string `json:"model"`
Status string `json:"status"`
Progress json.RawMessage `json:"progress,omitempty"`
OutputFileID string `json:"output_file_id,omitempty"`
ContentType string `json:"content_type,omitempty"`
Error string `json:"error,omitempty"`
CreatedAt time.Time `json:"created_at"`
StartedAt *time.Time `json:"started_at,omitempty"`
FinishedAt *time.Time `json:"finished_at,omitempty"`
}
func jobView(j store.Job) JobView {
v := JobView{ID: j.ID, Owner: j.Owner, KeyID: j.KeyID, Endpoint: j.Endpoint, Model: j.Model, Status: j.Status,
OutputFileID: j.OutputFileID, ContentType: j.ContentType, Error: j.Error, CreatedAt: j.CreatedAt}
if j.Progress != "" && json.Valid([]byte(j.Progress)) {
v.Progress = json.RawMessage(j.Progress)
}
if !j.StartedAt.IsZero() {
v.StartedAt = &j.StartedAt
}
if !j.FinishedAt.IsZero() {
v.FinishedAt = &j.FinishedAt
}
return v
}
func (a *API) jobs() (jobStore, bool) {
s, ok := a.usage.(jobStore)
return s, ok
}
func (a *API) listJobs(w http.ResponseWriter, r *http.Request) {
s, ok := a.jobs()
if !ok {
writeError(w, http.StatusNotImplemented, "jobs need the store, which this control plane runs without")
return
}
limit, _ := strconv.Atoi(r.URL.Query().Get("limit"))
js, err := s.AllJobs(r.Context(), r.URL.Query().Get("status"), limit)
if err != nil {
writeError(w, http.StatusInternalServerError, err.Error())
return
}
out := make([]JobView, 0, len(js))
for _, j := range js {
out = append(out, jobView(j))
}
writeJSON(w, http.StatusOK, out)
}
func (a *API) getJob(w http.ResponseWriter, r *http.Request) {
s, ok := a.jobs()
if !ok {
writeError(w, http.StatusNotImplemented, "jobs need the store, which this control plane runs without")
return
}
j, err := s.JobByID(r.Context(), r.PathValue("id"))
if errors.Is(err, store.ErrNotFound) {
writeError(w, http.StatusNotFound, "no job "+r.PathValue("id"))
return
}
if err != nil {
writeError(w, http.StatusInternalServerError, err.Error())
return
}
writeJSON(w, http.StatusOK, jobView(j))
}
func (a *API) cancelJob(w http.ResponseWriter, r *http.Request) {
s, ok := a.jobs()
if !ok {
writeError(w, http.StatusNotImplemented, "jobs need the store, which this control plane runs without")
return
}
if _, err := s.JobByID(r.Context(), r.PathValue("id")); errors.Is(err, store.ErrNotFound) {
writeError(w, http.StatusNotFound, "no job "+r.PathValue("id"))
return
}
j, err := s.CancelJob(r.Context(), r.PathValue("id"), time.Now())
if err != nil {
writeError(w, http.StatusInternalServerError, err.Error())
return
}
writeJSON(w, http.StatusOK, jobView(j))
}
+9
View File
@@ -62,6 +62,7 @@ var PathParams = map[string]string{
"jobs/{id}": "The job's ID, as starting it answered.",
"runs/{id}": "The quality run's ID, as starting it answered.",
"requests/{id}": "The request's ID: the x-request-id a client was answered with.",
"client-jobs/{id}": "The job's ID, job_….",
"fabrics/{id}": "The physical fabric's ID, as GET /api/v1/fabrics lists it.",
"quotas/{scope}": "The scope: org:NAME, team:ORG/TEAM, project:ORG/TEAM/PROJECT, or their IDs after the colon.",
"federation/{peer}": "The federation peer's name, as `llmgw ctl federation list` lists it.",
@@ -397,6 +398,14 @@ var Routes = []Route{
{Name: "format", Description: "json for JSON; CSV otherwise."},
},
Response: []store.ExportRow{}, CSV: true},
{Method: "GET", Path: "/api/v1/client-jobs", Summary: "Jobs clients asked for — 3D models — of every owner, newest first",
Query: []Param{
{Name: "status", Description: "Only jobs in this status: queued, running, cancelling, completed, failed, cancelled, expired."},
{Name: "limit", Type: "integer", Description: "The most jobs to answer with; 50 when absent."},
},
Response: []JobView{}},
{Method: "GET", Path: "/api/v1/client-jobs/{id}", Summary: "One job a client asked for", Response: JobView{}},
{Method: "POST", Path: "/api/v1/client-jobs/{id}/cancel", Summary: "Stop a job, in the engine's queue too", Response: JobView{}},
{Method: "GET", Path: "/api/v1/requests/{id}", Summary: "What one request went through",
Response: RequestView{}},
{Method: "GET", Path: "/api/v1/requests/{id}/body", Summary: "A kept request and its answer",
+5 -4
View File
@@ -57,6 +57,7 @@ func (r *Router) registerChat(mux *http.ServeMux, pages *web.AccountPages) {
web.ReplyRenderer(r.cfg.MaxBodyBytes)(w, req)
}))
r.registerImagesPage(mux, pages)
r.registerMeshesPage(mux, pages)
}
// chatSend dispatches one turn on behalf of a signed-in person.
@@ -257,12 +258,12 @@ func (r *Router) principalFor(req *http.Request, user store.User, asked string)
// by name, "big-model" came first and every visitor who pressed Send without
// touching the picker got placeholder text.
func (r *Router) modelsFor(req *http.Request, user store.User) []web.ChatModel {
return r.modelsOf(req, user, false)
return r.modelsOf(req, user, func(m catalog.Model) bool { return !m.MakesImages() && !m.MakesMeshes() })
}
// modelsOf is the models a person may use from a page: those that make
// pictures, or those that write text.
func (r *Router) modelsOf(req *http.Request, user store.User, pictures bool) []web.ChatModel {
func (r *Router) modelsOf(req *http.Request, user store.User, want func(catalog.Model) bool) []web.ChatModel {
principal, err := r.principalFor(req, user, req.URL.Query().Get("context"))
if err != nil {
return nil
@@ -290,7 +291,7 @@ func (r *Router) modelsOf(req *http.Request, user store.User, pictures bool) []w
continue
}
seen[name] = struct{}{}
if entry.MakesImages() == pictures && r.permits(principal, name) {
if want(entry) && r.permits(principal, name) {
out = append(out, web.ChatModel{Name: name, Simulated: entry.Simulated(), Hardware: hardware[name]})
}
}
@@ -306,7 +307,7 @@ func (r *Router) modelsOf(req *http.Request, user store.User, pictures bool) []w
continue
}
seen[name] = struct{}{}
if entry.MakesImages() == pictures && r.permits(principal, name) {
if want(entry) && r.permits(principal, name) {
out = append(out, web.ChatModel{
Name: name, Simulated: entry.Simulated(), OnDemand: true,
})
+1 -1
View File
@@ -333,7 +333,7 @@ func (r *Router) Handler() http.Handler {
}
exempt := []string{"/health", "/ready", "/leader", "/", "/about", "/_static/", "/_lang/", "/claim/",
"/signup", "/login", "/login/", "/logout", "/profile", "/profile/", "/scim/",
"/admin", "/admin/", "/chat", "/chat/", "/images", "/images/", "/org", "/org/", "/setup/"}
"/admin", "/admin/", "/chat", "/chat/", "/images", "/images/", "/3d", "/3d/", "/org", "/org/", "/setup/"}
// The docs are public unless the site said otherwise, and then guarded by
// the session check in front of them — or, on a gateway with keys and no
// accounts to sign in to, by the key like any other path.
+2 -1
View File
@@ -15,6 +15,7 @@ import (
"gitea.mynodes.xyz/ilker/llmgw/internal/auth"
"gitea.mynodes.xyz/ilker/llmgw/internal/comfy"
"gitea.mynodes.xyz/ilker/llmgw/internal/control/catalog"
"gitea.mynodes.xyz/ilker/llmgw/internal/router/endpoint"
"gitea.mynodes.xyz/ilker/llmgw/internal/router/proxy"
"gitea.mynodes.xyz/ilker/llmgw/internal/store"
@@ -248,7 +249,7 @@ func (r *Router) registerImagesPage(mux *http.ServeMux, pages *web.AccountPages)
if current == "" && !r.personalOff {
current = personalContext
}
web.Images(user, r.modelsOf(req, user, true), contexts, current, version.Version)(w, req)
web.Images(user, r.modelsOf(req, user, catalog.Model.MakesImages), contexts, current, version.Version)(w, req)
}))
mux.HandleFunc("POST /images/generate", pages.Guard(r.imagesSend))
}
+8 -1
View File
@@ -19,6 +19,7 @@ import (
"gitea.mynodes.xyz/ilker/llmgw/internal/control/catalog"
"gitea.mynodes.xyz/ilker/llmgw/internal/router/endpoint"
"gitea.mynodes.xyz/ilker/llmgw/internal/store"
"gitea.mynodes.xyz/ilker/llmgw/internal/web"
)
// imageRouter has a ComfyUI model, flux, beside a text model, and returns
@@ -244,7 +245,13 @@ func TestThePicturesPageOffersPictureModelsAndTheChatTheOthers(t *testing.T) {
user := store.User{ID: "usr-1", ProjectID: project}
names := func(pictures bool) []string {
var out []string
for _, m := range rt.modelsOf(httptest.NewRequest("GET", "/", nil), user, pictures) {
var models []web.ChatModel
if pictures {
models = rt.modelsOf(httptest.NewRequest("GET", "/", nil), user, catalog.Model.MakesImages)
} else {
models = rt.modelsFor(httptest.NewRequest("GET", "/", nil), user)
}
for _, m := range models {
out = append(out, m.Name)
}
return out
+33 -2
View File
@@ -3,6 +3,7 @@ package router
import (
"bytes"
"context"
"errors"
"fmt"
"net/http"
"os"
@@ -124,9 +125,9 @@ func (r *Router) serveJob(ctx context.Context, j *store.Job) error {
j.Status, j.Error, j.FinishedAt = store.JobFailed, msg, time.Now()
return r.store.UpdateJob(ctx, *j)
}
p, err := r.principalOfKey(ctx, j.KeyID, "")
p, err := r.principalOfJob(ctx, *j)
if err != nil {
return fail("the key this job was made with can no longer be used: " + err.Error())
return fail("the key or account this job was made with can no longer be used: " + err.Error())
}
// A cancel asked for while it runs ends the request, which takes the
@@ -227,3 +228,33 @@ func extensionFor(contentType string) string {
}
return ".bin"
}
// principalOfJob is who a job acts for, as they stand now: the key it was
// made with, or — for one made from the portal — the person whose session
// made it, while they may still use the gateway and the project the job is
// charged to.
func (r *Router) principalOfJob(ctx context.Context, j store.Job) (auth.Principal, error) {
uid, session := strings.CutPrefix(j.KeyID, "session:")
if !session {
return r.principalOfKey(ctx, j.KeyID, "")
}
u, err := r.store.UserByID(ctx, uid)
if err != nil {
return auth.Principal{}, err
}
if u.State != store.UserActive {
return auth.Principal{}, fmt.Errorf("the account that made it is %s", u.State)
}
project, _ := strings.CutPrefix(j.Owner, "project:")
if !strings.HasPrefix(j.Owner, "project:") {
project = ""
} else if ok, err := r.store.CanUseProject(ctx, uid, project); err != nil || !ok {
return auth.Principal{}, errors.New("its account is no longer a member of the project it is charged to")
}
eff, err := r.store.ResolveFor(ctx, j.KeyID, uid, project)
if err != nil {
return auth.Principal{}, err
}
return auth.Principal{KeyID: j.KeyID, KeyPrefix: "session", UserID: uid, ProjectID: eff.ProjectID,
TeamID: eff.TeamID, OrgID: eff.OrgID, Band: eff.Band, RoutingProfile: eff.RoutingProfile, Limits: eff}, nil
}
+113
View File
@@ -10,15 +10,20 @@ import (
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"strconv"
"strings"
"time"
"gitea.mynodes.xyz/ilker/llmgw/internal/auth"
"gitea.mynodes.xyz/ilker/llmgw/internal/comfy"
"gitea.mynodes.xyz/ilker/llmgw/internal/control/catalog"
"gitea.mynodes.xyz/ilker/llmgw/internal/router/endpoint"
"gitea.mynodes.xyz/ilker/llmgw/internal/router/proxy"
"gitea.mynodes.xyz/ilker/llmgw/internal/store"
"gitea.mynodes.xyz/ilker/llmgw/internal/version"
"gitea.mynodes.xyz/ilker/llmgw/internal/web"
)
// 3D models from a picture, made by ComfyUI. Clients ask for them as a job
@@ -268,3 +273,111 @@ func (r *Router) jobProgress(ctx context.Context, req *parsedRequest) func(comfy
}
}
}
// registerMeshesPage mounts the page that makes 3D models, beside the
// pictures page and for the same reasons: a session, never a key, and the
// request sent down the path an API client's takes — here, a job.
func (r *Router) registerMeshesPage(mux *http.ServeMux, pages *web.AccountPages) {
pages.SetMeshes(func() bool {
for _, m := range r.modelMap() {
if m.MakesMeshes() {
return true
}
}
return false
})
mux.HandleFunc("GET /3d", pages.Guard(func(w http.ResponseWriter, req *http.Request, user store.User) {
contexts, _ := r.chatContexts(req.Context(), user)
current, err := r.pickContext(req.Context(), user, req.URL.Query().Get("context"))
if err != nil {
current = ""
}
if current == "" && !r.personalOff {
current = personalContext
}
web.Meshes(user, r.modelsOf(req, user, catalog.Model.MakesMeshes), contexts, current, version.Version)(w, req)
}))
mux.HandleFunc("POST /3d/generate", pages.Guard(r.meshesSend))
mux.HandleFunc("GET /3d/jobs/{id}", pages.Guard(func(w http.ResponseWriter, req *http.Request, user store.User) {
if next, ok := r.asPerson(w, req, user, req.URL.Query().Get("context")); ok {
r.handleGetJob(w, next)
}
}))
// The mesh itself, from where the page is, for its viewer to load.
mux.HandleFunc("GET /3d/jobs/{id}/file", pages.Guard(func(w http.ResponseWriter, req *http.Request, user store.User) {
next, ok := r.asPerson(w, req, user, req.URL.Query().Get("context"))
if !ok {
return
}
p, _ := auth.FromContext(next.Context())
j, ok := r.ownedJob(w, next, ownerOf(p))
if !ok {
return
}
if j.OutputFileID == "" {
http.Error(w, "the job has made nothing yet", http.StatusNotFound)
return
}
b, err := r.store.FileContent(req.Context(), j.OutputFileID)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", j.ContentType)
w.Header().Set("Content-Disposition", fmt.Sprintf("inline; filename=%q", j.ID+".glb"))
_, _ = w.Write(b)
}))
}
// asPerson is a page's request as the signed-in person's, in the place they
// chose: what the API handlers read a key's principal from.
func (r *Router) asPerson(w http.ResponseWriter, req *http.Request, user store.User, context string) (*http.Request, bool) {
p, err := r.principalFor(req, user, context)
if err != nil {
http.Error(w, err.Error(), http.StatusForbidden)
return nil, false
}
return req.WithContext(auth.WithPrincipal(req.Context(), p)), true
}
// meshesSend asks for a 3D model on behalf of a signed-in person.
func (r *Router) meshesSend(w http.ResponseWriter, req *http.Request, user store.User) {
body, err := io.ReadAll(io.LimitReader(req.Body, r.cfg.MaxBodyBytes))
if err != nil {
http.Error(w, "could not read the request", http.StatusBadRequest)
return
}
var in struct {
Model string `json:"model"`
Image string `json:"image"`
Seed *int64 `json:"seed"`
Resolution int `json:"resolution"`
Context string `json:"context"`
}
if err := json.Unmarshal(body, &in); err != nil || in.Model == "" {
http.Error(w, "a model and a picture are required", http.StatusBadRequest)
return
}
// Rebuilt from the fields the page has, so it can set nothing else.
out := map[string]any{"model": in.Model, "image": in.Image}
if in.Seed != nil {
out["seed"] = *in.Seed
}
if in.Resolution > 0 {
out["resolution"] = in.Resolution
}
upstream, err := json.Marshal(out)
if err != nil {
http.Error(w, "could not build the request", http.StatusInternalServerError)
return
}
next, ok := r.asPerson(w, req, user, in.Context)
if !ok {
return
}
next = next.Clone(next.Context())
next.Body = io.NopCloser(bytes.NewReader(upstream))
next.ContentLength = int64(len(upstream))
next.Header.Set("Content-Type", "application/json")
r.handleCreateJob(w, next)
}
+71
View File
@@ -18,6 +18,7 @@ import (
"testing"
"time"
"gitea.mynodes.xyz/ilker/llmgw/internal/auth"
"gitea.mynodes.xyz/ilker/llmgw/internal/comfy"
"gitea.mynodes.xyz/ilker/llmgw/internal/config"
"gitea.mynodes.xyz/ilker/llmgw/internal/control/catalog"
@@ -287,3 +288,73 @@ func TestAnOBJLeavesTheGatewayAsAGLB(t *testing.T) {
}
}
}
func TestThe3DPageMakesAJobAndShowsItsMeshToItsOwnerOnly(t *testing.T) {
c := newMeshComfy(t)
rt, _ := meshRouter(t, c)
project := mustProjectOf(t, rt, "key-m")
user := store.User{ID: "usr-1", Email: "ann@studio.example", State: store.UserActive, CreatedAt: time.Now()}
if err := rt.store.CreateUser(t.Context(), user); err != nil {
t.Fatal(err)
}
if err := rt.store.AddMembership(t.Context(), user.ID, store.ScopeProject, project, "member", "test", time.Now()); err != nil {
t.Fatal(err)
}
org, _ := rt.store.CreateOrg(t.Context(), "other")
team, _ := rt.store.CreateTeam(t.Context(), org, "t")
otherProject, _ := rt.store.CreateProject(t.Context(), team, "p")
stranger := store.User{ID: "usr-2", Email: "bob@else.example", State: store.UserActive, CreatedAt: time.Now()}
_ = rt.store.CreateUser(t.Context(), stranger)
_ = rt.store.AddMembership(t.Context(), stranger.ID, store.ScopeProject, otherProject, "member", "test", time.Now())
body := `{"model":"trellis2","image":"` + testPicture(t) + `","resolution":256,"seed":5}`
rec := httptest.NewRecorder()
rt.meshesSend(rec, httptest.NewRequest("POST", "/3d/generate", strings.NewReader(body)), user)
if rec.Code != http.StatusAccepted {
t.Fatalf("%d %s", rec.Code, rec.Body.String())
}
var j map[string]any
_ = json.Unmarshal(rec.Body.Bytes(), &j)
id := j["id"].(string)
rt.wakeJobs()
get := func(u store.User, path string) *httptest.ResponseRecorder {
req := httptest.NewRequest("GET", path, nil)
req.SetPathValue("id", id)
rec := httptest.NewRecorder()
next, ok := rt.asPerson(rec, req, u, "")
if !ok {
return rec
}
if strings.HasSuffix(path, "/file") {
p, _ := auth.FromContext(next.Context())
jj, ok := rt.ownedJob(rec, next, ownerOf(p))
if ok {
b, _ := rt.store.FileContent(next.Context(), jj.OutputFileID)
rec.Header().Set("Content-Type", jj.ContentType)
_, _ = rec.Write(b)
}
return rec
}
rt.handleGetJob(rec, next)
return rec
}
deadline := time.Now().Add(10 * time.Second)
for {
rec := get(user, "/3d/jobs/"+id)
_ = json.Unmarshal(rec.Body.Bytes(), &j)
if j["status"] == "completed" {
break
}
if time.Now().After(deadline) {
t.Fatalf("not made: %s", rec.Body.String())
}
time.Sleep(20 * time.Millisecond)
}
if rec := get(user, "/3d/jobs/"+id+"/file"); !strings.HasPrefix(rec.Body.String(), "glTF") {
t.Errorf("the mesh: %q", rec.Body.String()[:min(20, rec.Body.Len())])
}
if rec := get(stranger, "/3d/jobs/"+id); rec.Code != http.StatusNotFound {
t.Errorf("another project's person read the job: %d", rec.Code)
}
}
+1 -1
View File
@@ -17,7 +17,7 @@ func TestSessionPagesAreNotAskedForAnAPIKey(t *testing.T) {
h := rt.Handler()
// The /admin pages are mounted only with a cluster view, which this
// router has none of; these are the session pages it does mount.
for _, path := range []string{"/profile", "/chat", "/images", "/org", "/org/org-x"} {
for _, path := range []string{"/profile", "/chat", "/images", "/3d", "/org", "/org/org-x"} {
w := httptest.NewRecorder()
h.ServeHTTP(w, httptest.NewRequest(http.MethodGet, path, nil))
if strings.Contains(w.Body.String(), "api key") {
+30
View File
@@ -161,6 +161,36 @@ func (s *DB) Jobs(ctx context.Context, owner, after string, limit int) ([]Job, e
return out, rows.Err()
}
// AllJobs is every owner's jobs, newest first, those in one status when it
// is named: what an operator looks over.
func (s *DB) AllJobs(ctx context.Context, status string, limit int) ([]Job, error) {
q := `SELECT ` + jobCols + ` FROM jobs`
var args []any
if status != "" {
q += ` WHERE status = ?`
args = append(args, status)
}
if limit <= 0 || limit > 500 {
limit = 50
}
q += ` ORDER BY created_at DESC LIMIT ?`
args = append(args, limit)
rows, err := s.db.QueryContext(ctx, q, args...)
if err != nil {
return nil, err
}
defer rows.Close()
var out []Job
for rows.Next() {
j, err := scanJob(rows)
if err != nil {
return nil, err
}
out = append(out, j)
}
return out, rows.Err()
}
// ClaimJob takes the lease on the oldest job with work left that no gateway
// holds, for owner until the time given. ok is false when there is none.
func (s *DB) ClaimJob(ctx context.Context, owner string, now, until time.Time) (Job, bool, error) {
+25
View File
@@ -1,6 +1,7 @@
package store
import (
"fmt"
"testing"
"time"
)
@@ -95,3 +96,27 @@ func checkJobs(t *testing.T, db *DB) {
t.Errorf("deleted %d", n)
}
}
func TestAnOperatorSeesEveryOwnersJobs(t *testing.T) {
db := capacityStore(t)
now := time.Now()
for i, owner := range []string{"project:a", "project:b", "user:c"} {
status := JobQueued
if i == 2 {
status = JobCompleted
}
if err := db.PutJob(t.Context(), Job{ID: fmt.Sprint("job_", i), Owner: owner, KeyID: "k", Endpoint: "/v1/3d/generations",
Model: "m", Input: []byte("{}"), Status: status, CreatedAt: now.Add(time.Duration(i) * time.Second),
ExpiresAt: now.Add(time.Hour)}); err != nil {
t.Fatal(err)
}
}
all, err := db.AllJobs(t.Context(), "", 0)
if err != nil || len(all) != 3 || all[0].ID != "job_2" {
t.Fatalf("%v %v: every owner's, newest first", all, err)
}
queued, _ := db.AllJobs(t.Context(), JobQueued, 0)
if len(queued) != 2 {
t.Errorf("%d queued", len(queued))
}
}
+1
View File
@@ -96,6 +96,7 @@ type AccountPages struct {
// images says whether some model makes pictures; nil when the
// pictures page is not mounted.
images func() bool
meshes func() bool
guardLibrary func() guard.Config
// guardFor names the guardrail policies in force for someone, and
// whether they keep nothing; nil when there are none.
+3 -1
View File
@@ -40,7 +40,9 @@ func contentSecurityPolicy(page []byte) string {
"script-src 'self'" + prefixSpace(strings.Join(hashes, " ")) + "; " +
"style-src 'self' 'unsafe-inline' https://fonts.googleapis.com; " +
"font-src 'self' https://fonts.gstatic.com; " +
"img-src 'self' data: https:; " + // model cards show their images
// Model cards show their images; a mesh's viewer hands its textures
// to the browser as blob: URLs.
"img-src 'self' data: blob: https:; " +
"connect-src 'self'; " +
"object-src 'none'; base-uri 'self'; form-action 'self'; frame-ancestors 'none'"
}
+16
View File
@@ -35,3 +35,19 @@ func Images(user store.User, models []ChatModel, contexts []ChatContext, current
// SetImages has the menu offer the pictures page while some model makes
// them. Asked on every page, so it must be cheap: the catalog, not a request.
func (p *AccountPages) SetImages(available func() bool) { p.images = available }
// Meshes renders the page that makes 3D models from a picture.
func Meshes(user store.User, models []ChatModel, contexts []ChatContext, current, version string) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
noStore(w)
render(w, r, "meshes", imagesData{
Nav: navFrom(r, "meshes"),
Contexts: contexts, Context: current,
User: user, Models: models, CSRF: csrfFor(r),
Version: version, Now: time.Now().UTC().Format(time.RFC3339),
})
}
}
// SetMeshes has the menu offer the 3D page while some model makes meshes.
func (p *AccountPages) SetMeshes(available func() bool) { p.meshes = available }
+25
View File
@@ -34,3 +34,28 @@ func TestThePicturesPageDrawsInEveryLanguage(t *testing.T) {
t.Error("no models, and the page does not say so")
}
}
func TestThe3DPageDrawsInEveryLanguageWithItsViewer(t *testing.T) {
for _, lang := range []string{"en", "tr"} {
req := httptest.NewRequest("GET", "/3d", nil)
req.Header.Set("Accept-Language", lang)
rec := httptest.NewRecorder()
Meshes(store.User{Email: "a@b.c"}, []ChatModel{{Name: "triposr"}},
[]ChatContext{{Value: "personal", Label: "Personal"}}, "personal", "v0")(rec, req)
page := rec.Body.String()
if rec.Code != 200 {
t.Fatalf("%s: %d %s", lang, rec.Code, page)
}
for _, want := range []string{`<option value="triposr">`, `id="picture"`, `/3d/generate`, `model-viewer.min.js?v=`} {
if !strings.Contains(page, want) {
t.Errorf("%s: %s missing", lang, want)
}
}
if strings.Contains(page, "meshes.") {
t.Errorf("%s: an untranslated key is on the page", lang)
}
if csp := rec.Header().Get("Content-Security-Policy"); !strings.Contains(csp, "script-src 'self'") || !strings.Contains(csp, "blob:") {
t.Errorf("policy %q", csp)
}
}
}
+20
View File
@@ -0,0 +1,20 @@
{
"meshes.title": "3D models",
"meshes.picture": "Picture",
"meshes.picture_hint": "one object, on a plain background; a PNG with a transparent background is best",
"meshes.resolution": "Detail",
"meshes.resolution_hint": "the model's grid: higher is finer and slower",
"meshes.seed": "Seed",
"meshes.make": "Make",
"meshes.kept": "A 3D model is made as a job: it waits for the card, then takes a minute or more. It is kept for the files' retention, and you can leave this page and come back to the job by its id through the API.",
"meshes.empty": "No model you may use makes 3D models right now.",
"meshes.empty_why": "A model that makes them is a ComfyUI model in the catalog with <code>output: meshes</code>.",
"meshes.js.queued": "Waiting for the card… {ahead} ahead",
"meshes.js.queued_none": "Waiting for the card…",
"meshes.js.running": "Making it… {node} {percent}%",
"meshes.js.done": "Made in {s} s.",
"meshes.js.failed": "Not made: {why}",
"meshes.js.download": "download the .glb",
"meshes.js.license": "Licence",
"meshes.js.no_picture": "Choose a picture first."
}
+2 -1
View File
@@ -12,5 +12,6 @@
"nav.sign_out": "Sign out",
"nav.docs": "Docs",
"nav.settings": "Settings",
"nav.images": "Pictures"
"nav.images": "Pictures",
"nav.meshes": "3D"
}
+20
View File
@@ -0,0 +1,20 @@
{
"meshes.title": "3D modeller",
"meshes.picture": "Resim",
"meshes.picture_hint": "düz bir arka plan önünde tek bir nesne; arka planı saydam bir PNG en iyisi",
"meshes.resolution": "Ayrıntı",
"meshes.resolution_hint": "modelin ızgarası: yüksek değer daha ince ve daha yavaş",
"meshes.seed": "Tohum",
"meshes.make": "Üret",
"meshes.kept": "3D model bir iş olarak üretilir: önce kartı bekler, sonra bir dakika ya da daha fazla sürer. Dosyaların saklama süresi boyunca tutulur; sayfadan ayrılıp işe API üzerinden kimliğiyle dönebilirsiniz.",
"meshes.empty": "Şu anda kullanabileceğiniz, 3D model üreten bir model yok.",
"meshes.empty_why": "3D model üreten model, katalogda <code>output: meshes</code> olan bir ComfyUI modelidir.",
"meshes.js.queued": "Kart bekleniyor… önünde {ahead} iş var",
"meshes.js.queued_none": "Kart bekleniyor…",
"meshes.js.running": "Üretiliyor… {node} %{percent}",
"meshes.js.done": "{s} sn'de üretildi.",
"meshes.js.failed": "Üretilemedi: {why}",
"meshes.js.download": ".glb dosyasını indir",
"meshes.js.license": "Lisans",
"meshes.js.no_picture": "Önce bir resim seçin."
}
+2 -1
View File
@@ -12,5 +12,6 @@
"nav.sign_out": "Çıkış yap",
"nav.docs": "Belgeler",
"nav.settings": "Ayarlar",
"nav.images": "Görseller"
"nav.images": "Görseller",
"nav.meshes": "3D"
}
+4 -2
View File
@@ -35,8 +35,9 @@ type Nav struct {
// Org offers the organization page: to an administrator, and to anyone
// who manages an organization.
Org bool
// Images offers the pictures page, while some model makes them.
Images bool
// Images offers the pictures page, while some model makes them; Meshes
// the 3D page.
Images, Meshes bool
}
type navKey struct{}
@@ -53,6 +54,7 @@ func (p *AccountPages) navFor(r *http.Request, user store.User, current string)
Settings: p.hasSettings && user.IsAdmin,
CSRF: csrfFor(r),
Images: p.images != nil && p.images(),
Meshes: p.meshes != nil && p.meshes(),
}
// Only when there is an organization to show: a link that leads to "there
// are none" on every page is noise.
+6
View File
@@ -927,3 +927,9 @@ a.sel-link.small { font-size: .78rem; color: var(--muted); margin-left: .4rem; }
.images-gallery img { display: block; width: 100%; height: auto; }
.images-gallery figcaption { font-size: .8rem; color: var(--muted); padding: .45rem .6rem 0; }
.images-prompt { font-size: .82rem; margin: .25rem .6rem .55rem; overflow-wrap: anywhere; }
/* The 3D page: the picture asked about, and each mesh in a viewer. */
.meshes-picture { display: block; margin: .6rem 0; font-size: .85rem; font-weight: 600; }
.meshes-picture input { display: block; margin-top: .3rem; font-weight: 400; }
.meshes-preview { max-width: min(100%, 16rem); max-height: 16rem; border: 1px solid var(--line); border-radius: 6px; }
.meshes-viewer { display: block; width: 100%; height: 22rem; background: var(--card); }
+202
View File
@@ -0,0 +1,202 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
File diff suppressed because it is too large. Load diff
+178
View File
@@ -0,0 +1,178 @@
{{define "meshes"}}<!doctype html>
<html lang="{{lang}}"><head>
<meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
<title>{{t "meshes.title"}} · llmgw</title><link rel="stylesheet" href="{{stylesheet}}">
<script defer src="{{asset "pages.js"}}"></script>
<script type="module" src="{{asset "model-viewer.min.js"}}"></script>
<meta name="csrf" content="{{.CSRF}}">
</head><body><div class="wrap">
<header>
<h1>{{t "meshes.title"}}</h1>
<p class="sub">{{.User.Email}}</p>
{{template "nav" .Nav}}
</header>
{{if gt (len .Contexts) 1}}
<form method="get" action="/3d" class="chat-context">
<label class="inline-label">{{t "chat.context.using"}}
<select id="context" name="context" data-autosubmit>
{{range .Contexts}}<option value="{{.Value}}"{{if eq .Value $.Context}} selected{{end}}>{{.Label}}</option>{{end}}
</select></label>
<noscript translate="no"><button type="submit" class="link">{{t "chat.context.switch"}}</button></noscript>
</form>
{{else if .Contexts}}{{with index .Contexts 0}}<input type="hidden" id="context" value="{{.Value}}">{{end}}{{end}}
{{if .Models}}
<form id="make" class="images-form">
<div class="chat-bar">
<label class="inline-label">{{t "chat.model"}}
<select id="model">{{range .Models}}<option value="{{.Name}}">{{.Name}}{{with .Runs}} · {{.}}{{end}}</option>{{end}}</select>
</label>
<label class="inline-label">{{t "meshes.resolution"}}
<select id="resolution" title="{{t "meshes.resolution_hint"}}">
<option value="">—</option><option>192</option><option>256</option><option>384</option><option>512</option>
</select></label>
<label class="inline-label">{{t "meshes.seed"}}
<input type="number" id="seed" min="0" step="1" class="images-num"></label>
</div>
<label class="meshes-picture">{{t "meshes.picture"}} <span class="opt">{{t "meshes.picture_hint"}}</span>
<input type="file" id="picture" accept="image/png,image/jpeg,image/webp"></label>
<img id="preview" class="meshes-preview" alt="" hidden>
<div class="chat-composer"><button type="submit" id="go">{{t "meshes.make"}}</button></div>
</form>
<p id="status" class="note" aria-live="polite"></p>
<div id="gallery" class="images-gallery"></div>
<p class="note">{{t "meshes.kept"}}</p>
{{else}}
<p class="empty">{{t "meshes.empty"}}</p>
<p class="note">{{th "meshes.empty_why"}}</p>
{{end}}
<footer><span>llmgw {{.Version}}</span><span>{{.Now}}</span>{{template "langs"}}</footer>
</div>
<script>
const say = {
queued: {{t "meshes.js.queued"}},
queuedNone: {{t "meshes.js.queued_none"}},
running: {{t "meshes.js.running"}},
done: {{t "meshes.js.done"}},
failed: {{t "meshes.js.failed"}},
download: {{t "meshes.js.download"}},
license: {{t "meshes.js.license"}},
noPicture: {{t "meshes.js.no_picture"}},
decimal: {{t "_meta.decimal"}},
};
function fill(s, vals) { return s.replace(/\{(\w+)\}/g, (m, k) => (k in vals ? String(vals[k]) : m)); }
function fixed(n, places) { return n.toFixed(places).replace(".", say.decimal); }
// A 3D model is a job: asked for, then asked after until it is made. The
// mesh is shown from the gateway itself, which the page's policy allows.
(function () {
const form = document.getElementById("make");
if (!form) return;
const csrf = document.querySelector('meta[name="csrf"]').content;
const $ = (id) => document.getElementById(id);
const status = $("status"), gallery = $("gallery"), go = $("go"), preview = $("preview");
let picture = "";
const ctx = () => ($("context") ? $("context").value : "");
$("picture").addEventListener("change", () => {
const f = $("picture").files[0];
if (!f) return;
const rd = new FileReader();
rd.addEventListener("load", () => {
picture = rd.result;
preview.src = picture;
preview.hidden = false;
});
rd.readAsDataURL(f);
});
function describe(j) {
const p = j.progress || {};
if (j.status === "queued" || p.state === "queued" || !p.state) {
return p.ahead ? fill(say.queued, { ahead: p.ahead }) : say.queuedNone;
}
return fill(say.running, { node: p.node_class || "", percent: p.percent || 0 });
}
async function follow(id, started) {
const q = ctx() ? "?context=" + encodeURIComponent(ctx()) : "";
for (;;) {
const resp = await fetch("/3d/jobs/" + encodeURIComponent(id) + q);
const j = await resp.json().catch(() => ({}));
if (!resp.ok) throw new Error((j.error && j.error.message) || String(resp.status));
if (j.status === "completed") return j;
if (["failed", "cancelled", "expired"].includes(j.status)) {
throw new Error((j.error && j.error.message) || j.status);
}
status.textContent = describe(j);
await new Promise((r) => setTimeout(r, 2000));
}
}
function show(j, took) {
const q = ctx() ? "?context=" + encodeURIComponent(ctx()) : "";
const src = "/3d/jobs/" + encodeURIComponent(j.id) + "/file" + q;
const fig = document.createElement("figure");
const mv = document.createElement("model-viewer");
mv.setAttribute("src", src);
mv.setAttribute("camera-controls", "");
mv.setAttribute("auto-rotate", "");
mv.setAttribute("shadow-intensity", "0.6");
mv.className = "meshes-viewer";
const cap = document.createElement("figcaption");
const line = document.createElement("span");
line.textContent = j.model + " · " + j.id + " · " + fill(say.done, { s: fixed(took, 0) });
const dl = document.createElement("a");
dl.href = src;
dl.download = j.id + ".glb";
dl.className = "link";
dl.textContent = say.download;
cap.append(line, " ", dl);
fig.append(mv, cap);
if (j.license) {
const lic = document.createElement("p");
lic.className = "images-prompt";
lic.textContent = say.license + ": " + j.license.name + (j.license.notice ? " — " + j.license.notice : "");
fig.append(lic);
}
gallery.prepend(fig);
}
form.addEventListener("submit", async (e) => {
e.preventDefault();
if (go.disabled) return;
if (!picture) { status.textContent = say.noPicture; return; }
const body = { model: $("model").value, image: picture, context: ctx() };
if ($("seed").value !== "") body.seed = Number($("seed").value);
if ($("resolution").value !== "") body.resolution = Number($("resolution").value);
go.disabled = true;
status.classList.remove("error");
status.textContent = say.queuedNone;
const start = performance.now();
try {
const resp = await fetch("/3d/generate", {
method: "POST", headers: { "Content-Type": "application/json", "X-CSRF-Token": csrf },
body: JSON.stringify(body),
});
const text = await resp.text();
let j = null;
try { j = JSON.parse(text); } catch (_) {}
if (!resp.ok || !j || !j.id) {
throw new Error(String((j && j.error && j.error.message) || text.trim() || resp.status));
}
const done = await follow(j.id, start);
const took = (performance.now() - start) / 1000;
status.textContent = fill(say.done, { s: fixed(took, 0) });
show(done, took);
} catch (err) {
status.textContent = fill(say.failed, { why: err.message });
status.classList.add("error");
} finally {
go.disabled = false;
}
});
})();
</script>
</body></html>{{end}}
+3
View File
@@ -31,6 +31,9 @@
{{- if .Images}}
<a href="/images"{{if eq .Current "images"}} aria-current="page"{{end}}>{{t "nav.images"}}</a>
{{- end}}
{{- if .Meshes}}
<a href="/3d"{{if eq .Current "meshes"}} aria-current="page"{{end}}>{{t "nav.meshes"}}</a>
{{- end}}
<a href="/profile"{{if eq .Current "keys"}} aria-current="page"{{end}}>{{t "nav.account"}}</a>
<a href="/docs"{{if eq .Current "docs"}} aria-current="page"{{end}}>{{t "nav.docs"}}</a>
<form method="post" action="/logout" class="inline">