feat: ninja CLI in its own repo (block/cli, WO-WZ-023)
The ninja developer CLI moves out of block/core into its own module git.dev.alexdunmow.com/block/cli. Pins block/core@v0.18.2 for abi/v1, the plugin.mod parser, and DESCRIBE guest builds; vendors its own orchestrator registry client (internal/api, generated from a vendored plugin_registry.proto) since it cannot import block/core/internal. Produces byte-identical v1 artifacts (verified: art-deco codeless SHA256-identical to the pre-move build). Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
Alex Dunmow
commit
2f065e3ed4
27
Makefile
Normal file
27
Makefile
Normal file
@ -0,0 +1,27 @@
|
||||
.PHONY: build install test proto tidy safety-check
|
||||
|
||||
# Build the ninja binary into ./bin/ninja.
|
||||
build:
|
||||
go build -o bin/ninja ./cmd/ninja
|
||||
|
||||
# Install ninja onto $GOBIN/$GOPATH/bin (yields `ninja` on PATH).
|
||||
install:
|
||||
go install ./cmd/ninja
|
||||
|
||||
# Run the full test suite (compiles guest wasm fixtures; needs the Go
|
||||
# toolchain with GOOS=wasip1 support and network access to the block/core
|
||||
# module proxy for the pinned guest SDK).
|
||||
test:
|
||||
go test ./...
|
||||
|
||||
# Regenerate the vendored orchestrator client from proto/.
|
||||
# Requires buf + protoc-gen-go + protoc-gen-connect-go on PATH.
|
||||
proto:
|
||||
buf generate --path proto/orchestrator/v1/plugin_registry.proto
|
||||
|
||||
tidy:
|
||||
go mod tidy
|
||||
|
||||
# Static safety gate (shared workspace tool).
|
||||
safety-check:
|
||||
cd ../check-safety && go run . ../cli
|
||||
18
buf.gen.yaml
Normal file
18
buf.gen.yaml
Normal file
@ -0,0 +1,18 @@
|
||||
version: v2
|
||||
# Managed mode overrides the vendored proto's go_package so the generated Go
|
||||
# lands in this module (git.dev.alexdunmow.com/block/cli/internal/api/...),
|
||||
# not the CMS/orchestrator package the proto file nominally declares.
|
||||
managed:
|
||||
enabled: true
|
||||
override:
|
||||
- file_option: go_package_prefix
|
||||
value: git.dev.alexdunmow.com/block/cli/internal/api
|
||||
plugins:
|
||||
- local: protoc-gen-go
|
||||
out: internal/api
|
||||
opt:
|
||||
- paths=source_relative
|
||||
- local: protoc-gen-connect-go
|
||||
out: internal/api
|
||||
opt:
|
||||
- paths=source_relative
|
||||
17
buf.yaml
Normal file
17
buf.yaml
Normal file
@ -0,0 +1,17 @@
|
||||
version: v2
|
||||
# Minimal buf module for the ninja CLI. We vendor a single proto —
|
||||
# orchestrator/v1/plugin_registry.proto — because the CLI only needs the
|
||||
# plugin registry/publish/auth/scope client to talk to the orchestrator. The
|
||||
# rest of orchestrator/v1 is generated by the orchestrator and CMS from their
|
||||
# own copies; the CLI never registers those descriptors.
|
||||
modules:
|
||||
- path: proto
|
||||
lint:
|
||||
use:
|
||||
- STANDARD
|
||||
except:
|
||||
- PACKAGE_SAME_GO_PACKAGE
|
||||
- RPC_REQUEST_RESPONSE_UNIQUE
|
||||
breaking:
|
||||
use:
|
||||
- FILE
|
||||
137
cmd/ninja/cmd/abi.go
Normal file
137
cmd/ninja/cmd/abi.go
Normal file
@ -0,0 +1,137 @@
|
||||
package cmd
|
||||
|
||||
import (
|
||||
"archive/tar"
|
||||
"compress/gzip"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
|
||||
"git.dev.alexdunmow.com/block/cli/internal/creds"
|
||||
"github.com/spf13/cobra"
|
||||
)
|
||||
|
||||
// newAbiCmd is the `ninja abi` group: fetch the versioned wasm-plugin ABI
|
||||
// contract (proto schema + calling-convention docs) the registry publishes, so
|
||||
// any language can codegen against it (WO-WZ-023).
|
||||
func newAbiCmd() *cobra.Command {
|
||||
c := &cobra.Command{
|
||||
Use: "abi",
|
||||
Short: "Work with the wasm-plugin ABI contract",
|
||||
Long: "Fetch the versioned ABI contract (proto schema + docs) published by the registry.",
|
||||
}
|
||||
c.AddCommand(newAbiPullCmd())
|
||||
return c
|
||||
}
|
||||
|
||||
func newAbiPullCmd() *cobra.Command {
|
||||
var version string
|
||||
var outDir string
|
||||
cmd := &cobra.Command{
|
||||
Use: "pull",
|
||||
Short: "Download and extract the ABI contract tarball from the registry",
|
||||
Long: "Fetches <host>/registry/abi/<version>/contract.tar.gz (public, no login\n" +
|
||||
"required) and extracts the proto schema + docs into a directory.",
|
||||
RunE: func(c *cobra.Command, _ []string) error {
|
||||
hostFlag, _ := c.Flags().GetString("host")
|
||||
host := resolveContractHost(hostFlag)
|
||||
|
||||
if !strings.HasPrefix(version, "v") {
|
||||
version = "v" + version
|
||||
}
|
||||
url := strings.TrimRight(host, "/") + "/registry/abi/" + version + "/contract.tar.gz"
|
||||
|
||||
req, err := http.NewRequestWithContext(c.Context(), http.MethodGet, url, nil)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
resp, err := http.DefaultClient.Do(req)
|
||||
if err != nil {
|
||||
return fmt.Errorf("fetch contract: %w", err)
|
||||
}
|
||||
defer func() { _ = resp.Body.Close() }()
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
body, _ := io.ReadAll(io.LimitReader(resp.Body, 512))
|
||||
return fmt.Errorf("registry returned %s for %s: %s", resp.Status, url, strings.TrimSpace(string(body)))
|
||||
}
|
||||
|
||||
if outDir == "" {
|
||||
outDir = filepath.Join("abi-contract", version)
|
||||
}
|
||||
n, err := extractContract(resp.Body, outDir)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
fmt.Printf("Pulled ABI contract %s → %s (%d files)\n", version, outDir, n)
|
||||
return nil
|
||||
},
|
||||
}
|
||||
cmd.Flags().StringVar(&version, "version", "v1", "ABI contract version to pull (e.g. v1)")
|
||||
cmd.Flags().StringVarP(&outDir, "output", "o", "", "output directory (default: abi-contract/<version>)")
|
||||
return cmd
|
||||
}
|
||||
|
||||
// resolveContractHost resolves the registry host for a public (unauthenticated)
|
||||
// download: the --host flag wins, else the logged-in default host, else the
|
||||
// production registry. It never errors on a missing token — the contract route
|
||||
// is public.
|
||||
func resolveContractHost(hostFlag string) string {
|
||||
if hostFlag != "" {
|
||||
return hostFlag
|
||||
}
|
||||
if cr, err := creds.Load(); err == nil && cr.DefaultHost != "" {
|
||||
return cr.DefaultHost
|
||||
}
|
||||
return "https://my.blockninjacms.com"
|
||||
}
|
||||
|
||||
// extractContract untars a gzip stream into dir, refusing any entry that would
|
||||
// escape the destination root. Returns the number of files written.
|
||||
func extractContract(r io.Reader, dir string) (int, error) {
|
||||
if err := os.MkdirAll(dir, 0o755); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
gz, err := gzip.NewReader(r)
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("open gzip: %w", err)
|
||||
}
|
||||
defer func() { _ = gz.Close() }()
|
||||
tr := tar.NewReader(gz)
|
||||
var count int
|
||||
for {
|
||||
hdr, err := tr.Next()
|
||||
if err == io.EOF {
|
||||
break
|
||||
}
|
||||
if err != nil {
|
||||
return count, fmt.Errorf("read tar: %w", err)
|
||||
}
|
||||
if hdr.Typeflag != tar.TypeReg {
|
||||
continue
|
||||
}
|
||||
clean := filepath.Clean(hdr.Name)
|
||||
if !filepath.IsLocal(clean) {
|
||||
return count, fmt.Errorf("refusing unsafe tar path %q", hdr.Name)
|
||||
}
|
||||
dest := filepath.Join(dir, clean)
|
||||
if err := os.MkdirAll(filepath.Dir(dest), 0o755); err != nil {
|
||||
return count, err
|
||||
}
|
||||
f, err := os.OpenFile(dest, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o644)
|
||||
if err != nil {
|
||||
return count, err
|
||||
}
|
||||
if _, err := io.Copy(f, tr); err != nil { //nolint:gosec // size-bounded contract tarball from our own registry
|
||||
_ = f.Close()
|
||||
return count, err
|
||||
}
|
||||
if err := f.Close(); err != nil {
|
||||
return count, err
|
||||
}
|
||||
count++
|
||||
}
|
||||
return count, nil
|
||||
}
|
||||
150
cmd/ninja/cmd/account.go
Normal file
150
cmd/ninja/cmd/account.go
Normal file
@ -0,0 +1,150 @@
|
||||
package cmd
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"context"
|
||||
"fmt"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"connectrpc.com/connect"
|
||||
"github.com/spf13/cobra"
|
||||
|
||||
"git.dev.alexdunmow.com/block/cli/internal/creds"
|
||||
"git.dev.alexdunmow.com/block/cli/internal/orchclient"
|
||||
v1 "git.dev.alexdunmow.com/block/cli/internal/api/orchestrator/v1"
|
||||
)
|
||||
|
||||
func newAccountCmd() *cobra.Command {
|
||||
c := &cobra.Command{
|
||||
Use: "account",
|
||||
Short: "Manage which account ninja acts as",
|
||||
Long: `Account-scoped commands like ` + "`ninja plugins publish --private`" + ` act
|
||||
against an "active account" — the orchestrator-side account whose members
|
||||
can see and install the plugin. The active account is selected at
|
||||
` + "`ninja login`" + ` time and persisted in your credentials file.`,
|
||||
}
|
||||
c.AddCommand(newAccountListCmd(), newAccountSetCmd(), newAccountShowCmd())
|
||||
return c
|
||||
}
|
||||
|
||||
func newAccountListCmd() *cobra.Command {
|
||||
return &cobra.Command{
|
||||
Use: "list",
|
||||
Short: "List the accounts the authenticated user belongs to",
|
||||
RunE: func(c *cobra.Command, _ []string) error {
|
||||
cli, _, _, hc, err := resolveClient(c)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
accts, err := cli.Auth.ListMyAccountsForCLI(context.Background(),
|
||||
connect.NewRequest(&v1.ListMyAccountsForCLIRequest{}))
|
||||
if err != nil {
|
||||
return fmt.Errorf("list accounts: %w", err)
|
||||
}
|
||||
if len(accts.Msg.Accounts) == 0 {
|
||||
fmt.Println("No accounts.")
|
||||
return nil
|
||||
}
|
||||
for _, a := range accts.Msg.Accounts {
|
||||
marker := " "
|
||||
if a.Id == hc.ActiveAccountID {
|
||||
marker = "* "
|
||||
}
|
||||
fmt.Printf("%s%s — %s\n", marker, a.Slug, a.Name)
|
||||
}
|
||||
return nil
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func newAccountSetCmd() *cobra.Command {
|
||||
return &cobra.Command{
|
||||
Use: "set <slug>",
|
||||
Short: "Change the active account",
|
||||
Args: cobra.ExactArgs(1),
|
||||
RunE: func(c *cobra.Command, args []string) error {
|
||||
cli, cr, host, hc, err := resolveClient(c)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
slug := strings.TrimPrefix(args[0], "@")
|
||||
accts, err := cli.Auth.ListMyAccountsForCLI(context.Background(),
|
||||
connect.NewRequest(&v1.ListMyAccountsForCLIRequest{}))
|
||||
if err != nil {
|
||||
return fmt.Errorf("list accounts: %w", err)
|
||||
}
|
||||
for _, a := range accts.Msg.Accounts {
|
||||
if a.Slug == slug {
|
||||
hc.ActiveAccountID = a.Id
|
||||
hc.ActiveAccountSlug = a.Slug
|
||||
cr.Hosts[host] = hc
|
||||
if err := cr.Save(); err != nil {
|
||||
return err
|
||||
}
|
||||
fmt.Printf("Active account: %s (%s)\n", a.Slug, a.Name)
|
||||
return nil
|
||||
}
|
||||
}
|
||||
return fmt.Errorf("account %q not found among your memberships; try `ninja account list`", slug)
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func newAccountShowCmd() *cobra.Command {
|
||||
return &cobra.Command{
|
||||
Use: "show",
|
||||
Short: "Show the currently active account",
|
||||
RunE: func(c *cobra.Command, _ []string) error {
|
||||
_, _, _, hc, err := resolveClient(c)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if hc.ActiveAccountSlug == "" {
|
||||
fmt.Println("(no active account set; run `ninja login` or `ninja account set <slug>`)")
|
||||
return nil
|
||||
}
|
||||
fmt.Printf("Active account: %s (id=%s)\n", hc.ActiveAccountSlug, hc.ActiveAccountID)
|
||||
return nil
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// resolveClient is a small helper used by every `ninja account` subcommand:
|
||||
// it loads creds, resolves the host, and returns an authed client plus the
|
||||
// loaded credentials so the caller can persist changes.
|
||||
func resolveClient(c *cobra.Command) (*orchclient.Client, *creds.Credentials, string, creds.HostCreds, error) {
|
||||
host, _ := c.Flags().GetString("host")
|
||||
cr, err := creds.Load()
|
||||
if err != nil {
|
||||
return nil, nil, "", creds.HostCreds{}, err
|
||||
}
|
||||
resolvedHost, hc, err := cr.Resolve(host)
|
||||
if err != nil {
|
||||
return nil, nil, "", creds.HostCreds{}, err
|
||||
}
|
||||
return orchclient.New(resolvedHost, hc.Token), cr, resolvedHost, hc, nil
|
||||
}
|
||||
|
||||
// pickAccountInteractive prompts the user to select an account by number from
|
||||
// the given list and returns the chosen account. Used by `ninja login` when
|
||||
// the user belongs to more than one account.
|
||||
func pickAccountInteractive(scanner *bufio.Scanner, accounts []*v1.MyAccount) (*v1.MyAccount, error) {
|
||||
if len(accounts) == 0 {
|
||||
return nil, fmt.Errorf("no accounts available")
|
||||
}
|
||||
fmt.Println("Select an account:")
|
||||
for i, a := range accounts {
|
||||
fmt.Printf(" %d) %s — %s\n", i+1, a.Slug, a.Name)
|
||||
}
|
||||
fmt.Print("> ")
|
||||
if !scanner.Scan() {
|
||||
return nil, fmt.Errorf("cancelled")
|
||||
}
|
||||
v := strings.TrimSpace(scanner.Text())
|
||||
n, err := strconv.Atoi(v)
|
||||
if err != nil || n < 1 || n > len(accounts) {
|
||||
return nil, fmt.Errorf("invalid selection: %s", v)
|
||||
}
|
||||
return accounts[n-1], nil
|
||||
}
|
||||
150
cmd/ninja/cmd/login.go
Normal file
150
cmd/ninja/cmd/login.go
Normal file
@ -0,0 +1,150 @@
|
||||
package cmd
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"context"
|
||||
"fmt"
|
||||
"os"
|
||||
"time"
|
||||
|
||||
"connectrpc.com/connect"
|
||||
"github.com/spf13/cobra"
|
||||
|
||||
"git.dev.alexdunmow.com/block/cli/internal/creds"
|
||||
"git.dev.alexdunmow.com/block/cli/internal/orchclient"
|
||||
v1 "git.dev.alexdunmow.com/block/cli/internal/api/orchestrator/v1"
|
||||
)
|
||||
|
||||
func newLoginCmd() *cobra.Command {
|
||||
var host string
|
||||
cmd := &cobra.Command{
|
||||
Use: "login",
|
||||
Short: "Authenticate against the orchestrator using device flow",
|
||||
RunE: func(c *cobra.Command, _ []string) error {
|
||||
if host == "" {
|
||||
host, _ = c.Flags().GetString("host")
|
||||
}
|
||||
if host == "" {
|
||||
host = "https://my.blockninjacms.com"
|
||||
}
|
||||
cli := orchclient.New(host, "")
|
||||
ctx := context.Background()
|
||||
start, err := cli.Auth.StartDevice(ctx, connect.NewRequest(&v1.StartDeviceRequest{
|
||||
Scopes: []string{"plugin:read", "plugin:publish", "scope:admin"},
|
||||
}))
|
||||
if err != nil {
|
||||
return fmt.Errorf("start device: %w", err)
|
||||
}
|
||||
fmt.Printf("Visit %s?user_code=%s to authorize.\n", start.Msg.VerificationUri, start.Msg.UserCode)
|
||||
interval := time.Duration(start.Msg.IntervalSeconds) * time.Second
|
||||
deadline := time.Now().Add(time.Duration(start.Msg.ExpiresInSeconds) * time.Second)
|
||||
for time.Now().Before(deadline) {
|
||||
time.Sleep(interval)
|
||||
poll, err := cli.Auth.PollDevice(ctx, connect.NewRequest(&v1.PollDeviceRequest{DeviceCode: start.Msg.DeviceCode}))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
switch poll.Msg.Status {
|
||||
case "pending":
|
||||
continue
|
||||
case "approved":
|
||||
cr, err := creds.Load()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
cr.DefaultHost = host
|
||||
if cr.Hosts == nil {
|
||||
cr.Hosts = map[string]creds.HostCreds{}
|
||||
}
|
||||
hc := creds.HostCreds{Token: poll.Msg.AccessToken}
|
||||
authed := orchclient.New(host, hc.Token)
|
||||
if err := selectActiveAccount(ctx, authed, &hc); err != nil {
|
||||
return err
|
||||
}
|
||||
cr.Hosts[host] = hc
|
||||
if err := cr.Save(); err != nil {
|
||||
return err
|
||||
}
|
||||
fmt.Println("Logged in.")
|
||||
return nil
|
||||
case "expired":
|
||||
return fmt.Errorf("device code expired; try again")
|
||||
}
|
||||
}
|
||||
return fmt.Errorf("login timed out")
|
||||
},
|
||||
}
|
||||
cmd.Flags().StringVar(&host, "host", "", "Orchestrator base URL")
|
||||
return cmd
|
||||
}
|
||||
|
||||
func newWhoamiCmd() *cobra.Command {
|
||||
return &cobra.Command{
|
||||
Use: "whoami",
|
||||
Short: "Show the currently logged-in user",
|
||||
RunE: func(c *cobra.Command, _ []string) error {
|
||||
host, _ := c.Flags().GetString("host")
|
||||
cr, err := creds.Load()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
resolvedHost, hc, err := cr.Resolve(host)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
cli := orchclient.New(resolvedHost, hc.Token)
|
||||
r, err := cli.Auth.Whoami(context.Background(), connect.NewRequest(&v1.WhoamiRequest{}))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
fmt.Printf("%s <%s> at %s\n", r.Msg.DisplayName, r.Msg.Email, resolvedHost)
|
||||
return nil
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// selectActiveAccount fetches the user's accounts and writes the active one
|
||||
// into hc. With 0 accounts it errors (the server contract guarantees every
|
||||
// user has at least one). With 1 it auto-selects silently. With ≥2 it
|
||||
// prompts interactively on stdin.
|
||||
func selectActiveAccount(ctx context.Context, cli *orchclient.Client, hc *creds.HostCreds) error {
|
||||
resp, err := cli.Auth.ListMyAccountsForCLI(ctx, connect.NewRequest(&v1.ListMyAccountsForCLIRequest{}))
|
||||
if err != nil {
|
||||
return fmt.Errorf("list accounts: %w", err)
|
||||
}
|
||||
accts := resp.Msg.Accounts
|
||||
switch len(accts) {
|
||||
case 0:
|
||||
return fmt.Errorf("no accounts found for this user; contact support")
|
||||
case 1:
|
||||
hc.ActiveAccountID = accts[0].Id
|
||||
hc.ActiveAccountSlug = accts[0].Slug
|
||||
fmt.Printf("Active account: %s (%s)\n", accts[0].Slug, accts[0].Name)
|
||||
return nil
|
||||
}
|
||||
chosen, err := pickAccountInteractive(bufio.NewScanner(os.Stdin), accts)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
hc.ActiveAccountID = chosen.Id
|
||||
hc.ActiveAccountSlug = chosen.Slug
|
||||
fmt.Printf("Active account: %s (%s)\n", chosen.Slug, chosen.Name)
|
||||
return nil
|
||||
}
|
||||
|
||||
func newLogoutCmd() *cobra.Command {
|
||||
return &cobra.Command{
|
||||
Use: "logout",
|
||||
Short: "Remove stored credentials",
|
||||
RunE: func(c *cobra.Command, _ []string) error {
|
||||
host, _ := c.Flags().GetString("host")
|
||||
cr, err := creds.Load()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
resolvedHost, _, _ := cr.Resolve(host)
|
||||
delete(cr.Hosts, resolvedHost)
|
||||
return cr.Save()
|
||||
},
|
||||
}
|
||||
}
|
||||
1238
cmd/ninja/cmd/plugin.go
Normal file
1238
cmd/ninja/cmd/plugin.go
Normal file
File diff suppressed because it is too large
Load Diff
140
cmd/ninja/cmd/plugin_build.go
Normal file
140
cmd/ninja/cmd/plugin_build.go
Normal file
@ -0,0 +1,140 @@
|
||||
package cmd
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
"github.com/spf13/cobra"
|
||||
|
||||
"git.dev.alexdunmow.com/block/cli/internal/bnp"
|
||||
)
|
||||
|
||||
func newPluginBuildCmd() *cobra.Command {
|
||||
var dir, output string
|
||||
var codeless bool
|
||||
cmd := &cobra.Command{
|
||||
Use: "build",
|
||||
Short: "Compile a plugin to wasm and pack a .bnp artifact",
|
||||
Long: `Compile the plugin in --dir to reactor-mode wasip1 wasm, extract its
|
||||
static manifest by instantiating the module once (HOOK_DESCRIBE), and pack a
|
||||
.bnp (tar.zst of plugin.wasm, plugin.mod, manifest.pb, plus migrations/,
|
||||
schemas/, assets/, web/dist when present).
|
||||
|
||||
No Docker or podman: the whole pipeline is the local Go toolchain (>= 1.24)
|
||||
plus wazero. This replaces the in-container .so compile.`,
|
||||
RunE: func(c *cobra.Command, _ []string) error {
|
||||
// Classify by repo shape (WO-WZ-020): no Go source → codeless
|
||||
// (declarative, no wasm); Go source → wasm. --codeless asserts
|
||||
// the expectation and fails loudly on a mismatch.
|
||||
isCodeless, err := bnp.IsCodelessRepo(dir)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if codeless && !isCodeless {
|
||||
return fmt.Errorf("--codeless asserted but %s contains Go source — a codeless plugin has no code (delete the Go or drop the flag)", dir)
|
||||
}
|
||||
var res *bnp.BuildResult
|
||||
if isCodeless {
|
||||
res, err = bnp.BuildCodeless(context.Background(), bnp.BuildOptions{Dir: dir, Output: output})
|
||||
} else {
|
||||
res, err = bnp.Build(context.Background(), bnp.BuildOptions{Dir: dir, Output: output})
|
||||
}
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
printBuildSummary(res)
|
||||
return nil
|
||||
},
|
||||
}
|
||||
cmd.Flags().StringVar(&dir, "dir", ".", "Plugin repo directory")
|
||||
cmd.Flags().StringVarP(&output, "output", "o", "", "Output .bnp path (default <name>-<version>.bnp)")
|
||||
cmd.Flags().BoolVar(&codeless, "codeless", false, "Assert the repo builds a codeless (no-wasm) artifact; fail if it contains Go source")
|
||||
return cmd
|
||||
}
|
||||
|
||||
func newPluginVerifyCmd() *cobra.Command {
|
||||
cmd := &cobra.Command{
|
||||
Use: "verify <file.bnp>",
|
||||
Short: "Validate a .bnp against the loader's layout/name/abi/path/size checks",
|
||||
Long: `Re-run the CMS reader's checks on a .bnp standalone so CI and the registry
|
||||
can gate uploads: required members present, path-safety and size caps on
|
||||
extraction, manifest decodes, abi_version supported, and manifest name matches
|
||||
plugin.mod. Prints a named reason for each malformed class.`,
|
||||
Args: cobra.ExactArgs(1),
|
||||
RunE: func(c *cobra.Command, args []string) error {
|
||||
res, err := bnp.Verify(args[0])
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
printVerifySummary(args[0], res)
|
||||
return nil
|
||||
},
|
||||
}
|
||||
return cmd
|
||||
}
|
||||
|
||||
func printBuildSummary(r *bnp.BuildResult) {
|
||||
hooks := "(none)"
|
||||
if len(r.Hooks) > 0 {
|
||||
hooks = strings.Join(r.Hooks, ", ")
|
||||
}
|
||||
dirs := "(none)"
|
||||
if len(r.IncludedDirs) > 0 {
|
||||
dirs = strings.Join(r.IncludedDirs, ", ")
|
||||
}
|
||||
kind := "wasm"
|
||||
if r.Codeless {
|
||||
kind = "codeless"
|
||||
}
|
||||
fmt.Printf("Built %s@%s (%s) → %s\n", r.Name, r.Version, kind, r.OutputPath)
|
||||
fmt.Println(" ┌───────────────────────────────────────────")
|
||||
fmt.Printf(" │ artifact size %s (%s uncompressed)\n", humanBytes(r.ArtifactBytes), humanBytes(r.UncompBytes))
|
||||
fmt.Printf(" │ plugin.wasm %s\n", humanBytes(r.WasmBytes))
|
||||
fmt.Printf(" │ manifest.pb %s\n", humanBytes(r.ManifestBytes))
|
||||
fmt.Printf(" │ blocks %d\n", r.BlockCount)
|
||||
fmt.Printf(" │ templates %d\n", r.TemplateCount)
|
||||
fmt.Printf(" │ admin pages %d\n", r.AdminPages)
|
||||
fmt.Printf(" │ job types %d\n", r.JobTypes)
|
||||
fmt.Printf(" │ hooks %s\n", hooks)
|
||||
fmt.Printf(" │ bundled dirs %s\n", dirs)
|
||||
fmt.Printf(" │ data_dir grant %t\n", r.DataDir)
|
||||
fmt.Println(" └───────────────────────────────────────────")
|
||||
}
|
||||
|
||||
func printVerifySummary(path string, r *bnp.VerifyResult) {
|
||||
var dirs []string
|
||||
if r.HasMigrations {
|
||||
dirs = append(dirs, "migrations")
|
||||
}
|
||||
if r.HasSchemas {
|
||||
dirs = append(dirs, "schemas")
|
||||
}
|
||||
if r.HasAssets {
|
||||
dirs = append(dirs, "assets")
|
||||
}
|
||||
if r.HasWeb {
|
||||
dirs = append(dirs, "web")
|
||||
}
|
||||
joined := "(none)"
|
||||
if len(dirs) > 0 {
|
||||
joined = strings.Join(dirs, ", ")
|
||||
}
|
||||
fmt.Printf("OK: %s\n", path)
|
||||
fmt.Printf(" name=%s version=%s abi_version=%d blocks=%d data_dir=%t dirs=[%s]\n",
|
||||
r.Name, r.Version, r.ABIVersion, r.BlockCount, r.DataDir, joined)
|
||||
}
|
||||
|
||||
// humanBytes formats a byte count with a binary unit suffix.
|
||||
func humanBytes(n int64) string {
|
||||
const unit = 1024
|
||||
if n < unit {
|
||||
return fmt.Sprintf("%d B", n)
|
||||
}
|
||||
div, exp := int64(unit), 0
|
||||
for x := n / unit; x >= unit; x /= unit {
|
||||
div *= unit
|
||||
exp++
|
||||
}
|
||||
return fmt.Sprintf("%.1f %ciB", float64(n)/float64(div), "KMGTPE"[exp])
|
||||
}
|
||||
281
cmd/ninja/cmd/plugin_build_test.go
Normal file
281
cmd/ninja/cmd/plugin_build_test.go
Normal file
@ -0,0 +1,281 @@
|
||||
package cmd
|
||||
|
||||
import (
|
||||
"archive/tar"
|
||||
"context"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"slices"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
abiv1 "git.dev.alexdunmow.com/block/core/abi/v1"
|
||||
"git.dev.alexdunmow.com/block/cli/internal/bnp"
|
||||
"github.com/klauspost/compress/zstd"
|
||||
"google.golang.org/protobuf/proto"
|
||||
)
|
||||
|
||||
// fixtureDir resolves a guest-plugin fixture under this package's testdata/.
|
||||
// The fixtures compile against the cli module's pinned block/core@v0.18.x
|
||||
// (guest SDK), which is exactly what `ninja plugin build` drives in the wild.
|
||||
func fixtureDir(t *testing.T, name string) string {
|
||||
t.Helper()
|
||||
dir, err := filepath.Abs(filepath.Join("testdata", name))
|
||||
if err != nil {
|
||||
t.Fatalf("resolve fixture %s: %v", name, err)
|
||||
}
|
||||
if _, err := os.Stat(filepath.Join(dir, "plugin.mod")); err != nil {
|
||||
t.Fatalf("fixture %s missing plugin.mod: %v", name, err)
|
||||
}
|
||||
return dir
|
||||
}
|
||||
|
||||
// TestPluginBuildAndVerify is the WO-WZ-009 acceptance e2e: build the WZ-002
|
||||
// fixture repo → a .bnp exists, `verify` passes, and its manifest decodes with
|
||||
// the expected block keys and the data_dir grant from plugin.mod.
|
||||
func TestPluginBuildAndVerify(t *testing.T) {
|
||||
if testing.Short() {
|
||||
t.Skip("compiles a wasm module; skipped in -short")
|
||||
}
|
||||
out := filepath.Join(t.TempDir(), "wasmfixture-0.0.1.bnp")
|
||||
|
||||
res, err := bnp.Build(context.Background(), bnp.BuildOptions{
|
||||
Dir: fixtureDir(t, "fixture"),
|
||||
Output: out,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("build: %v", err)
|
||||
}
|
||||
if res.Name != "wasmfixture" || res.Version != "0.0.1" {
|
||||
t.Errorf("identity = %q/%q", res.Name, res.Version)
|
||||
}
|
||||
if res.BlockCount != 1 || res.TemplateCount != 1 || res.AdminPages != 1 {
|
||||
t.Errorf("counts blocks=%d templates=%d admin=%d", res.BlockCount, res.TemplateCount, res.AdminPages)
|
||||
}
|
||||
if !res.DataDir {
|
||||
t.Errorf("data_dir grant not carried from plugin.mod into the manifest")
|
||||
}
|
||||
if !slices.Contains(res.Hooks, "load") {
|
||||
t.Errorf("hooks = %v, want load present", res.Hooks)
|
||||
}
|
||||
if _, err := os.Stat(out); err != nil {
|
||||
t.Fatalf("artifact not written: %v", err)
|
||||
}
|
||||
|
||||
// verify passes on the produced artifact.
|
||||
vr, err := bnp.Verify(out)
|
||||
if err != nil {
|
||||
t.Fatalf("verify: %v", err)
|
||||
}
|
||||
if vr.Name != "wasmfixture" || vr.ABIVersion != 1 || !vr.DataDir {
|
||||
t.Errorf("verify result = %+v", vr)
|
||||
}
|
||||
|
||||
// manifest decodes with expected block keys.
|
||||
m, err := bnp.ReadManifest(out)
|
||||
if err != nil {
|
||||
t.Fatalf("read manifest: %v", err)
|
||||
}
|
||||
var keys []string
|
||||
for _, b := range m.GetBlocks() {
|
||||
keys = append(keys, b.GetKey())
|
||||
}
|
||||
if !slices.Contains(keys, "wasmfixture:greeting") {
|
||||
t.Errorf("block keys = %v, want wasmfixture:greeting", keys)
|
||||
}
|
||||
if !slices.Contains(m.GetTemplateKeys(), "wasmfixture-page") {
|
||||
t.Errorf("template keys = %v, want wasmfixture-page", m.GetTemplateKeys())
|
||||
}
|
||||
if !m.GetDataDir() {
|
||||
t.Errorf("manifest.data_dir = false, want true")
|
||||
}
|
||||
}
|
||||
|
||||
// TestPluginBuildDefaultOutputName confirms the default artifact name is
|
||||
// <name>-<version>.bnp in the working directory.
|
||||
func TestPluginBuildDefaultOutputName(t *testing.T) {
|
||||
if testing.Short() {
|
||||
t.Skip("compiles a wasm module; skipped in -short")
|
||||
}
|
||||
dir := fixtureDir(t, "fixture") // resolve to an absolute path before chdir
|
||||
wd, _ := os.Getwd()
|
||||
t.Cleanup(func() { _ = os.Chdir(wd) })
|
||||
tmp := t.TempDir()
|
||||
if err := os.Chdir(tmp); err != nil {
|
||||
t.Fatalf("chdir: %v", err)
|
||||
}
|
||||
res, err := bnp.Build(context.Background(), bnp.BuildOptions{Dir: dir})
|
||||
if err != nil {
|
||||
t.Fatalf("build: %v", err)
|
||||
}
|
||||
if res.OutputPath != "wasmfixture-0.0.1.bnp" {
|
||||
t.Errorf("default output = %q", res.OutputPath)
|
||||
}
|
||||
if _, err := os.Stat(filepath.Join(tmp, "wasmfixture-0.0.1.bnp")); err != nil {
|
||||
t.Errorf("default artifact not in cwd: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// TestPluginBuildCapabilityInRegisterFails proves a plugin that reaches a host
|
||||
// capability at describe time fails with an actionable error naming the call.
|
||||
func TestPluginBuildCapabilityInRegisterFails(t *testing.T) {
|
||||
if testing.Short() {
|
||||
t.Skip("compiles a wasm module; skipped in -short")
|
||||
}
|
||||
out := filepath.Join(t.TempDir(), "capfixture.bnp")
|
||||
_, err := bnp.Build(context.Background(), bnp.BuildOptions{
|
||||
Dir: fixtureDir(t, "capfixture"),
|
||||
Output: out,
|
||||
})
|
||||
if err == nil {
|
||||
t.Fatal("expected build to fail on a describe-time capability call")
|
||||
}
|
||||
msg := err.Error()
|
||||
if !strings.Contains(msg, "db.query") || !strings.Contains(msg, "manifest extraction") {
|
||||
t.Errorf("error not actionable: %q (want it to name db.query + manifest extraction)", msg)
|
||||
}
|
||||
if _, statErr := os.Stat(out); statErr == nil {
|
||||
t.Errorf("a .bnp must not be written when the build fails")
|
||||
}
|
||||
}
|
||||
|
||||
// --- verify rejection classes (fast; no wasm compile) ---
|
||||
|
||||
type fakeEntry struct {
|
||||
name string
|
||||
data []byte
|
||||
typeflag byte
|
||||
}
|
||||
|
||||
// writeTarZst crafts an arbitrary tar.zst for the malformed-artifact tests.
|
||||
func writeTarZst(t *testing.T, entries []fakeEntry) string {
|
||||
t.Helper()
|
||||
path := filepath.Join(t.TempDir(), "artifact.bnp")
|
||||
f, err := os.Create(path)
|
||||
if err != nil {
|
||||
t.Fatalf("create: %v", err)
|
||||
}
|
||||
defer func() { _ = f.Close() }()
|
||||
enc, _ := zstd.NewWriter(f)
|
||||
tw := tar.NewWriter(enc)
|
||||
for _, e := range entries {
|
||||
typ := e.typeflag
|
||||
if typ == 0 {
|
||||
typ = tar.TypeReg
|
||||
}
|
||||
hdr := &tar.Header{Name: e.name, Typeflag: typ, Mode: 0o644, Size: int64(len(e.data))}
|
||||
if typ == tar.TypeSymlink {
|
||||
hdr.Linkname = string(e.data)
|
||||
hdr.Size = 0
|
||||
}
|
||||
if err := tw.WriteHeader(hdr); err != nil {
|
||||
t.Fatalf("hdr %q: %v", e.name, err)
|
||||
}
|
||||
if typ == tar.TypeReg {
|
||||
if _, err := tw.Write(e.data); err != nil {
|
||||
t.Fatalf("write %q: %v", e.name, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
_ = tw.Close()
|
||||
_ = enc.Close()
|
||||
return path
|
||||
}
|
||||
|
||||
func manifestBytes(t *testing.T, name string, abi uint32) []byte {
|
||||
t.Helper()
|
||||
b, err := proto.Marshal(&abiv1.PluginManifest{Name: name, Version: "1.0.0", AbiVersion: abi})
|
||||
if err != nil {
|
||||
t.Fatalf("marshal manifest: %v", err)
|
||||
}
|
||||
return b
|
||||
}
|
||||
|
||||
func TestVerifyRejectsMalformed(t *testing.T) {
|
||||
validMod := []byte("[plugin]\nname = \"demo\"\nversion = \"1.0.0\"\n")
|
||||
|
||||
cases := []struct {
|
||||
name string
|
||||
entries []fakeEntry
|
||||
wantMsg string
|
||||
}{
|
||||
{
|
||||
name: "missing manifest.pb",
|
||||
entries: []fakeEntry{
|
||||
{name: "plugin.wasm", data: []byte("\x00asm")},
|
||||
{name: "plugin.mod", data: validMod},
|
||||
},
|
||||
wantMsg: "missing required manifest.pb",
|
||||
},
|
||||
{
|
||||
name: "undecodable manifest",
|
||||
entries: []fakeEntry{
|
||||
{name: "plugin.wasm", data: []byte("\x00asm")},
|
||||
{name: "plugin.mod", data: validMod},
|
||||
{name: "manifest.pb", data: []byte("not-a-proto\xff\xff")},
|
||||
},
|
||||
wantMsg: "decode manifest.pb",
|
||||
},
|
||||
{
|
||||
name: "unsupported abi_version",
|
||||
entries: []fakeEntry{
|
||||
{name: "plugin.wasm", data: []byte("\x00asm")},
|
||||
{name: "plugin.mod", data: validMod},
|
||||
{name: "manifest.pb", data: manifestBytes(t, "demo", 2)},
|
||||
},
|
||||
wantMsg: "unsupported abi_version 2",
|
||||
},
|
||||
{
|
||||
name: "empty manifest name",
|
||||
entries: []fakeEntry{
|
||||
{name: "plugin.wasm", data: []byte("\x00asm")},
|
||||
{name: "plugin.mod", data: validMod},
|
||||
{name: "manifest.pb", data: manifestBytes(t, "", 1)},
|
||||
},
|
||||
wantMsg: "empty name",
|
||||
},
|
||||
{
|
||||
name: "name mismatch",
|
||||
entries: []fakeEntry{
|
||||
{name: "plugin.wasm", data: []byte("\x00asm")},
|
||||
{name: "plugin.mod", data: validMod},
|
||||
{name: "manifest.pb", data: manifestBytes(t, "other", 1)},
|
||||
},
|
||||
wantMsg: "!= plugin.mod name",
|
||||
},
|
||||
{
|
||||
name: "absolute path entry",
|
||||
entries: []fakeEntry{
|
||||
{name: "/etc/passwd", data: []byte("x")},
|
||||
},
|
||||
wantMsg: "absolute entry path",
|
||||
},
|
||||
{
|
||||
name: "traversal entry",
|
||||
entries: []fakeEntry{
|
||||
{name: "../escape.txt", data: []byte("x")},
|
||||
},
|
||||
wantMsg: "traversal segment",
|
||||
},
|
||||
{
|
||||
name: "symlink entry",
|
||||
entries: []fakeEntry{
|
||||
{name: "link", data: []byte("/etc/passwd"), typeflag: tar.TypeSymlink},
|
||||
},
|
||||
wantMsg: "non-regular entry",
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
path := writeTarZst(t, tc.entries)
|
||||
_, err := bnp.Verify(path)
|
||||
if err == nil {
|
||||
t.Fatalf("expected rejection, got nil")
|
||||
}
|
||||
if !strings.Contains(err.Error(), tc.wantMsg) {
|
||||
t.Errorf("error %q does not mention %q", err.Error(), tc.wantMsg)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
175
cmd/ninja/cmd/plugin_tags.go
Normal file
175
cmd/ninja/cmd/plugin_tags.go
Normal file
@ -0,0 +1,175 @@
|
||||
package cmd
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"os"
|
||||
"slices"
|
||||
"sort"
|
||||
"strings"
|
||||
|
||||
"connectrpc.com/connect"
|
||||
"github.com/spf13/cobra"
|
||||
|
||||
core "git.dev.alexdunmow.com/block/core/plugin"
|
||||
"git.dev.alexdunmow.com/block/cli/internal/creds"
|
||||
"git.dev.alexdunmow.com/block/cli/internal/orchclient"
|
||||
v1 "git.dev.alexdunmow.com/block/cli/internal/api/orchestrator/v1"
|
||||
)
|
||||
|
||||
func newPluginTagsCmd() *cobra.Command {
|
||||
cmd := &cobra.Command{
|
||||
Use: "tags",
|
||||
Short: "Show current tags and popular tags from the registry",
|
||||
RunE: func(c *cobra.Command, _ []string) error {
|
||||
mod, err := readLocalMod()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if len(mod.Plugin.Tags) == 0 {
|
||||
fmt.Println("Current tags: (none)")
|
||||
} else {
|
||||
fmt.Printf("Current tags: %s\n", strings.Join(mod.Plugin.Tags, ", "))
|
||||
}
|
||||
|
||||
host, _ := c.Flags().GetString("host")
|
||||
cr, err := creds.Load()
|
||||
if err != nil {
|
||||
return nil // not signed in is fine — silent best-effort
|
||||
}
|
||||
resolvedHost, hc, err := cr.Resolve(host)
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
cli := orchclient.New(resolvedHost, hc.Token)
|
||||
line := fetchPopularTagsForList(cli, mod.Plugin.Kind)
|
||||
fmt.Println(line)
|
||||
return nil
|
||||
},
|
||||
}
|
||||
|
||||
cmd.AddCommand(&cobra.Command{
|
||||
Use: "add <tag>...",
|
||||
Short: "Add tags to the local plugin.mod (union with current)",
|
||||
Args: cobra.MinimumNArgs(1),
|
||||
RunE: func(_ *cobra.Command, args []string) error { return mutateTags("add", args) },
|
||||
})
|
||||
cmd.AddCommand(&cobra.Command{
|
||||
Use: "rm <tag>...",
|
||||
Short: "Remove tags from the local plugin.mod",
|
||||
Args: cobra.MinimumNArgs(1),
|
||||
RunE: func(_ *cobra.Command, args []string) error { return mutateTags("rm", args) },
|
||||
})
|
||||
cmd.AddCommand(&cobra.Command{
|
||||
Use: "set <tag>...",
|
||||
Short: "Replace all tags in the local plugin.mod",
|
||||
Args: cobra.MinimumNArgs(1),
|
||||
RunE: func(_ *cobra.Command, args []string) error { return mutateTags("set", args) },
|
||||
})
|
||||
cmd.AddCommand(&cobra.Command{
|
||||
Use: "clear",
|
||||
Short: "Remove all tags from the local plugin.mod",
|
||||
Args: cobra.NoArgs,
|
||||
RunE: func(_ *cobra.Command, _ []string) error { return mutateTags("clear", nil) },
|
||||
})
|
||||
|
||||
return cmd
|
||||
}
|
||||
|
||||
// mutateTags reads plugin.mod, computes the new tag set, normalises, and writes
|
||||
// it back. Prints the before→after diff and a reminder to publish.
|
||||
func mutateTags(op string, args []string) error {
|
||||
mod, err := readLocalMod()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
before := append([]string(nil), mod.Plugin.Tags...)
|
||||
|
||||
var next []string
|
||||
switch op {
|
||||
case "add":
|
||||
next = append(append([]string(nil), before...), args...)
|
||||
case "rm":
|
||||
drop := map[string]struct{}{}
|
||||
for _, a := range args {
|
||||
drop[strings.ToLower(strings.TrimSpace(a))] = struct{}{}
|
||||
}
|
||||
for _, t := range before {
|
||||
if _, gone := drop[t]; !gone {
|
||||
next = append(next, t)
|
||||
}
|
||||
}
|
||||
case "set":
|
||||
next = append([]string(nil), args...)
|
||||
case "clear":
|
||||
next = nil
|
||||
default:
|
||||
return fmt.Errorf("unknown tag op: %s", op)
|
||||
}
|
||||
|
||||
normalised, err := core.NormalizeTags(next)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if err := writeLocalModTags(mod, normalised); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
sortedBefore := append([]string(nil), before...)
|
||||
sortedAfter := append([]string(nil), normalised...)
|
||||
sort.Strings(sortedBefore)
|
||||
sort.Strings(sortedAfter)
|
||||
fmt.Printf("Tags: [%s] → [%s]\n", strings.Join(sortedBefore, ", "), strings.Join(sortedAfter, ", "))
|
||||
if !slices.Equal(sortedBefore, sortedAfter) {
|
||||
fmt.Println("Run 'ninja plugin publish' to push to the registry.")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func readLocalMod() (*core.ModFile, error) {
|
||||
b, err := os.ReadFile("plugin.mod")
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("read plugin.mod: %w", err)
|
||||
}
|
||||
mod, err := core.ParseModFull(b)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("parse plugin.mod: %w", err)
|
||||
}
|
||||
return mod, nil
|
||||
}
|
||||
|
||||
// writeLocalModTags rewrites plugin.mod with the new tag set, preserving all
|
||||
// other fields by reusing upsertPluginMod.
|
||||
func writeLocalModTags(mod *core.ModFile, tags []string) error {
|
||||
return upsertPluginMod(
|
||||
mod.Plugin.Scope,
|
||||
mod.Plugin.Name,
|
||||
mod.Plugin.DisplayName,
|
||||
mod.Plugin.Description,
|
||||
mod.Plugin.Kind,
|
||||
mod.Plugin.Categories,
|
||||
tags,
|
||||
mod.Plugin.Private,
|
||||
)
|
||||
}
|
||||
|
||||
// fetchPopularTagsForList returns a single user-facing line listing the most-used
|
||||
// tags for the given kind. Renders "Popular: tag (count), ...", "Popular tags:
|
||||
// (none yet)" when no tags exist on public plugins yet, or an "(unreachable)"
|
||||
// notice if the RPC fails.
|
||||
func fetchPopularTagsForList(cli *orchclient.Client, kind string) string {
|
||||
resp, err := cli.Reg.ListTags(context.Background(), connect.NewRequest(&v1.ListTagsRequest{Kind: kind, Limit: 20}))
|
||||
if err != nil {
|
||||
return "(could not fetch popular tags — orchestrator unreachable)"
|
||||
}
|
||||
if len(resp.Msg.Tags) == 0 {
|
||||
return "Popular tags: (none yet)"
|
||||
}
|
||||
parts := make([]string, len(resp.Msg.Tags))
|
||||
for i, t := range resp.Msg.Tags {
|
||||
parts[i] = fmt.Sprintf("%s (%d)", t.Tag, t.Count)
|
||||
}
|
||||
return "Popular: " + strings.Join(parts, ", ")
|
||||
}
|
||||
|
||||
637
cmd/ninja/cmd/plugin_test.go
Normal file
637
cmd/ninja/cmd/plugin_test.go
Normal file
@ -0,0 +1,637 @@
|
||||
package cmd
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"os"
|
||||
"os/exec"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
core "git.dev.alexdunmow.com/block/core/plugin"
|
||||
)
|
||||
|
||||
func TestCheckRepoHasHEAD_NoCommitsReturnsFriendlyError(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
runGit(t, dir, "init", "-q")
|
||||
|
||||
err := checkRepoHasHEAD(dir)
|
||||
if err == nil {
|
||||
t.Fatal("expected error for repo with no commits, got nil")
|
||||
}
|
||||
if !strings.Contains(err.Error(), "no commits in repository") {
|
||||
t.Errorf("error %q should mention 'no commits in repository'", err.Error())
|
||||
}
|
||||
if !strings.Contains(err.Error(), "git commit") {
|
||||
t.Errorf("error %q should suggest `git commit`", err.Error())
|
||||
}
|
||||
}
|
||||
|
||||
func TestCheckRepoHasHEAD_WithCommitReturnsNil(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
runGit(t, dir, "init", "-q")
|
||||
if err := os.WriteFile(filepath.Join(dir, "f"), []byte("hi"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
runGit(t, dir, "add", "f")
|
||||
runGit(t, dir, "commit", "-qm", "init")
|
||||
|
||||
if err := checkRepoHasHEAD(dir); err != nil {
|
||||
t.Errorf("expected nil for repo with a commit, got %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAutoCommitPluginMod_CommitsWhenDirty(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
runGit(t, dir, "init", "-q")
|
||||
if err := os.WriteFile(filepath.Join(dir, "README.md"), []byte("hi"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
runGit(t, dir, "add", "README.md")
|
||||
runGit(t, dir, "commit", "-qm", "init")
|
||||
|
||||
if err := os.WriteFile(filepath.Join(dir, "plugin.mod"),
|
||||
[]byte("[plugin]\nname = \"x\"\nscope = \"@s\"\nversion = \"0.1.0\"\n"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
t.Chdir(dir)
|
||||
if err := autoCommitPluginMod("Add plugin.mod"); err != nil {
|
||||
t.Fatalf("autoCommitPluginMod: %v", err)
|
||||
}
|
||||
|
||||
subject := gitLogSubject(t, dir)
|
||||
if subject != "Add plugin.mod" {
|
||||
t.Errorf("expected latest commit subject 'Add plugin.mod', got %q", subject)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAutoCommitPluginMod_NoopWhenClean(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
runGit(t, dir, "init", "-q")
|
||||
if err := os.WriteFile(filepath.Join(dir, "plugin.mod"),
|
||||
[]byte("[plugin]\nname = \"x\"\nscope = \"@s\"\nversion = \"0.1.0\"\n"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
runGit(t, dir, "add", "plugin.mod")
|
||||
runGit(t, dir, "commit", "-qm", "seed")
|
||||
|
||||
beforeSHA := gitHeadSHA(t, dir)
|
||||
|
||||
t.Chdir(dir)
|
||||
if err := autoCommitPluginMod("Add plugin.mod"); err != nil {
|
||||
t.Fatalf("autoCommitPluginMod: %v", err)
|
||||
}
|
||||
|
||||
afterSHA := gitHeadSHA(t, dir)
|
||||
if afterSHA != beforeSHA {
|
||||
t.Errorf("expected no new commit, HEAD moved %s -> %s", beforeSHA, afterSHA)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAutoCommitPluginMod_WorksOnDetachedHEAD(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
runGit(t, dir, "init", "-q")
|
||||
if err := os.WriteFile(filepath.Join(dir, "README.md"), []byte("hi"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
runGit(t, dir, "add", "README.md")
|
||||
runGit(t, dir, "commit", "-qm", "init")
|
||||
|
||||
initialSHA := gitHeadSHA(t, dir)
|
||||
runGit(t, dir, "checkout", "-q", initialSHA)
|
||||
|
||||
if err := os.WriteFile(filepath.Join(dir, "plugin.mod"),
|
||||
[]byte("[plugin]\nname = \"x\"\nscope = \"@s\"\nversion = \"0.1.0\"\n"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
t.Chdir(dir)
|
||||
if err := autoCommitPluginMod("Add plugin.mod"); err != nil {
|
||||
t.Fatalf("autoCommitPluginMod on detached HEAD: %v", err)
|
||||
}
|
||||
|
||||
afterSHA := gitHeadSHA(t, dir)
|
||||
if afterSHA == initialSHA {
|
||||
t.Fatalf("expected new commit on detached HEAD, HEAD still at %s", afterSHA)
|
||||
}
|
||||
|
||||
subject := gitLogSubject(t, dir)
|
||||
if subject != "Add plugin.mod" {
|
||||
t.Errorf("expected latest commit subject 'Add plugin.mod', got %q", subject)
|
||||
}
|
||||
|
||||
parentCmd := exec.Command("git", "rev-parse", "HEAD^")
|
||||
parentCmd.Dir = dir
|
||||
parentOut, err := parentCmd.CombinedOutput()
|
||||
if err != nil {
|
||||
t.Fatalf("git rev-parse HEAD^: %v\n%s", err, parentOut)
|
||||
}
|
||||
parentSHA := strings.TrimSpace(string(parentOut))
|
||||
if parentSHA != initialSHA {
|
||||
t.Errorf("expected new commit parent to be %s, got %s", initialSHA, parentSHA)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAutoCommitPluginMod_UsesProvidedMessage(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
runGit(t, dir, "init", "-q")
|
||||
if err := os.WriteFile(filepath.Join(dir, "README.md"), []byte("hi"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
runGit(t, dir, "add", "README.md")
|
||||
runGit(t, dir, "commit", "-qm", "init")
|
||||
|
||||
if err := os.WriteFile(filepath.Join(dir, "plugin.mod"),
|
||||
[]byte("[plugin]\nname = \"x\"\nscope = \"@s\"\nversion = \"0.3.0\"\n"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
t.Chdir(dir)
|
||||
if err := autoCommitPluginMod("bump to 0.3.0"); err != nil {
|
||||
t.Fatalf("autoCommitPluginMod: %v", err)
|
||||
}
|
||||
|
||||
if got := gitLogSubject(t, dir); got != "bump to 0.3.0" {
|
||||
t.Errorf("expected commit subject 'bump to 0.3.0', got %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAutoCommitPluginMod_LeavesOtherStagedPathsAlone(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
runGit(t, dir, "init", "-q")
|
||||
if err := os.WriteFile(filepath.Join(dir, "README.md"), []byte("hi"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
runGit(t, dir, "add", "README.md")
|
||||
runGit(t, dir, "commit", "-qm", "init")
|
||||
|
||||
// Stage an unrelated change that publish should NOT sweep up into the
|
||||
// plugin.mod auto-commit.
|
||||
if err := os.WriteFile(filepath.Join(dir, "other.txt"), []byte("scratch"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
runGit(t, dir, "add", "other.txt")
|
||||
|
||||
if err := os.WriteFile(filepath.Join(dir, "plugin.mod"),
|
||||
[]byte("[plugin]\nname = \"x\"\nscope = \"@s\"\nversion = \"0.3.0\"\n"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
t.Chdir(dir)
|
||||
if err := autoCommitPluginMod("bump to 0.3.0"); err != nil {
|
||||
t.Fatalf("autoCommitPluginMod: %v", err)
|
||||
}
|
||||
|
||||
// The new commit should touch plugin.mod only.
|
||||
filesCmd := exec.Command("git", "show", "--name-only", "--pretty=", "HEAD")
|
||||
filesCmd.Dir = dir
|
||||
filesOut, err := filesCmd.CombinedOutput()
|
||||
if err != nil {
|
||||
t.Fatalf("git show: %v\n%s", err, filesOut)
|
||||
}
|
||||
files := strings.Fields(strings.TrimSpace(string(filesOut)))
|
||||
if len(files) != 1 || files[0] != "plugin.mod" {
|
||||
t.Errorf("expected commit to touch only plugin.mod, got %v", files)
|
||||
}
|
||||
|
||||
// other.txt should still be staged (waiting for the developer to deal with).
|
||||
statusCmd := exec.Command("git", "status", "--porcelain", "other.txt")
|
||||
statusCmd.Dir = dir
|
||||
statusOut, _ := statusCmd.Output()
|
||||
if !strings.HasPrefix(strings.TrimSpace(string(statusOut)), "A ") {
|
||||
t.Errorf("expected other.txt to remain staged ('A '), got %q", string(statusOut))
|
||||
}
|
||||
}
|
||||
|
||||
func TestAutoCommitPluginMod_ErrorsWhenGitMissing(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
runGit(t, dir, "init", "-q")
|
||||
if err := os.WriteFile(filepath.Join(dir, "README.md"), []byte("hi"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
runGit(t, dir, "add", "README.md")
|
||||
runGit(t, dir, "commit", "-qm", "init")
|
||||
|
||||
if err := os.WriteFile(filepath.Join(dir, "plugin.mod"),
|
||||
[]byte("[plugin]\nname = \"x\"\nscope = \"@s\"\nversion = \"0.1.0\"\n"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
t.Chdir(dir)
|
||||
t.Setenv("PATH", "")
|
||||
|
||||
err := autoCommitPluginMod("Add plugin.mod")
|
||||
if err == nil {
|
||||
t.Fatal("expected error when git is missing from PATH, got nil")
|
||||
}
|
||||
if !strings.Contains(err.Error(), "git") {
|
||||
t.Errorf("error %q should mention 'git'", err.Error())
|
||||
}
|
||||
}
|
||||
|
||||
func gitLogSubject(t *testing.T, dir string) string {
|
||||
t.Helper()
|
||||
cmd := exec.Command("git", "log", "-1", "--pretty=%s")
|
||||
cmd.Dir = dir
|
||||
out, err := cmd.CombinedOutput()
|
||||
if err != nil {
|
||||
t.Fatalf("git log: %v\n%s", err, out)
|
||||
}
|
||||
return strings.TrimSpace(string(out))
|
||||
}
|
||||
|
||||
func gitHeadSHA(t *testing.T, dir string) string {
|
||||
t.Helper()
|
||||
cmd := exec.Command("git", "rev-parse", "HEAD")
|
||||
cmd.Dir = dir
|
||||
out, err := cmd.CombinedOutput()
|
||||
if err != nil {
|
||||
t.Fatalf("git rev-parse: %v\n%s", err, out)
|
||||
}
|
||||
return strings.TrimSpace(string(out))
|
||||
}
|
||||
|
||||
func TestGitignoredTrackedWarning_FiresWhenTrackedFileMatchesGitignore(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
runGit(t, dir, "init", "-q")
|
||||
if err := os.WriteFile(filepath.Join(dir, "secret.env"), []byte("token=abc"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
runGit(t, dir, "add", "secret.env")
|
||||
runGit(t, dir, "commit", "-qm", "init")
|
||||
if err := os.WriteFile(filepath.Join(dir, ".gitignore"), []byte("*.env\n"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
runGit(t, dir, "add", ".gitignore")
|
||||
runGit(t, dir, "commit", "-qm", "ignore")
|
||||
|
||||
var buf bytes.Buffer
|
||||
gitignoredTrackedWarning(dir, &buf)
|
||||
|
||||
out := buf.String()
|
||||
if !strings.Contains(out, "secret.env") {
|
||||
t.Errorf("warning should list secret.env, got: %q", out)
|
||||
}
|
||||
if !strings.Contains(out, "git rm --cached") {
|
||||
t.Errorf("warning should suggest `git rm --cached`, got: %q", out)
|
||||
}
|
||||
if !strings.HasSuffix(out, "\n") {
|
||||
t.Errorf("warning should end with a newline (Fprintln), got: %q", out)
|
||||
}
|
||||
}
|
||||
|
||||
func TestGitignoredTrackedWarning_NoopWhenNothingMatches(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
runGit(t, dir, "init", "-q")
|
||||
if err := os.WriteFile(filepath.Join(dir, "README.md"), []byte("hi"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
runGit(t, dir, "add", "README.md")
|
||||
runGit(t, dir, "commit", "-qm", "init")
|
||||
|
||||
var buf bytes.Buffer
|
||||
gitignoredTrackedWarning(dir, &buf)
|
||||
if buf.Len() != 0 {
|
||||
t.Errorf("expected empty output for clean repo, got: %q", buf.String())
|
||||
}
|
||||
}
|
||||
|
||||
func TestUntrackedFilesWarning_FiresWithUntrackedFile(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
runGit(t, dir, "init", "-q")
|
||||
if err := os.WriteFile(filepath.Join(dir, "README.md"), []byte("hi"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
runGit(t, dir, "add", "README.md")
|
||||
runGit(t, dir, "commit", "-qm", "init")
|
||||
|
||||
if err := os.WriteFile(filepath.Join(dir, "notes.txt"), []byte("scratch"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
var buf bytes.Buffer
|
||||
untrackedFilesWarning(dir, &buf)
|
||||
|
||||
out := buf.String()
|
||||
if !strings.Contains(out, "notes.txt") {
|
||||
t.Errorf("warning should list notes.txt, got: %q", out)
|
||||
}
|
||||
if !strings.Contains(out, "git add") {
|
||||
t.Errorf("warning should suggest `git add`, got: %q", out)
|
||||
}
|
||||
}
|
||||
|
||||
func TestUntrackedFilesWarning_NoopWithNoUntracked(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
runGit(t, dir, "init", "-q")
|
||||
if err := os.WriteFile(filepath.Join(dir, "README.md"), []byte("hi"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
runGit(t, dir, "add", "README.md")
|
||||
runGit(t, dir, "commit", "-qm", "init")
|
||||
|
||||
var buf bytes.Buffer
|
||||
untrackedFilesWarning(dir, &buf)
|
||||
if buf.Len() != 0 {
|
||||
t.Errorf("expected empty output, got: %q", buf.String())
|
||||
}
|
||||
}
|
||||
|
||||
func TestSubmoduleWarning_FiresWithGitmodules(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
runGit(t, dir, "init", "-q")
|
||||
gitmodules := `[submodule "vendor/foo"]
|
||||
path = vendor/foo
|
||||
url = https://example.com/foo.git
|
||||
`
|
||||
if err := os.WriteFile(filepath.Join(dir, ".gitmodules"), []byte(gitmodules), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
var buf bytes.Buffer
|
||||
submoduleWarning(dir, &buf)
|
||||
|
||||
out := buf.String()
|
||||
if !strings.Contains(out, "vendor/foo") {
|
||||
t.Errorf("warning should mention vendor/foo, got: %q", out)
|
||||
}
|
||||
if !strings.Contains(out, "submodules") {
|
||||
t.Errorf("warning should mention submodules, got: %q", out)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSubmoduleWarning_NoopWithoutGitmodules(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
runGit(t, dir, "init", "-q")
|
||||
|
||||
var buf bytes.Buffer
|
||||
submoduleWarning(dir, &buf)
|
||||
if buf.Len() != 0 {
|
||||
t.Errorf("expected empty output, got: %q", buf.String())
|
||||
}
|
||||
}
|
||||
|
||||
func TestEmitPublishWarnings_WarnsAboutGitignoreTracked(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
runGit(t, dir, "init", "-q")
|
||||
if err := os.WriteFile(filepath.Join(dir, "secret.env"), []byte("token=abc"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
runGit(t, dir, "add", "secret.env")
|
||||
runGit(t, dir, "commit", "-qm", "init")
|
||||
if err := os.WriteFile(filepath.Join(dir, ".gitignore"), []byte("*.env\n"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
runGit(t, dir, "add", ".gitignore")
|
||||
runGit(t, dir, "commit", "-qm", "ignore")
|
||||
|
||||
var buf bytes.Buffer
|
||||
if err := emitPublishWarnings(dir, false, &buf); err != nil {
|
||||
t.Fatalf("emitPublishWarnings: %v", err)
|
||||
}
|
||||
|
||||
out := buf.String()
|
||||
if !strings.Contains(out, "secret.env") {
|
||||
t.Errorf("expected gitignored-tracked warning to mention secret.env, got: %q", out)
|
||||
}
|
||||
if !strings.Contains(out, "match .gitignore") {
|
||||
t.Errorf("expected gitignored-tracked warning fragment, got: %q", out)
|
||||
}
|
||||
}
|
||||
|
||||
func TestEmitPublishWarnings_WarnsAboutSubmodules(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
runGit(t, dir, "init", "-q")
|
||||
if err := os.WriteFile(filepath.Join(dir, "README.md"), []byte("hi"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
runGit(t, dir, "add", "README.md")
|
||||
runGit(t, dir, "commit", "-qm", "init")
|
||||
|
||||
gitmodules := `[submodule "vendor/foo"]
|
||||
path = vendor/foo
|
||||
url = https://example.com/foo.git
|
||||
`
|
||||
if err := os.WriteFile(filepath.Join(dir, ".gitmodules"), []byte(gitmodules), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
runGit(t, dir, "add", ".gitmodules")
|
||||
runGit(t, dir, "commit", "-qm", "add submodule decl")
|
||||
|
||||
var buf bytes.Buffer
|
||||
if err := emitPublishWarnings(dir, false, &buf); err != nil {
|
||||
t.Fatalf("emitPublishWarnings: %v", err)
|
||||
}
|
||||
|
||||
out := buf.String()
|
||||
if !strings.Contains(out, "vendor/foo") {
|
||||
t.Errorf("expected submodule warning to mention vendor/foo, got: %q", out)
|
||||
}
|
||||
if !strings.Contains(out, "submodules") {
|
||||
t.Errorf("expected submodule warning fragment, got: %q", out)
|
||||
}
|
||||
}
|
||||
|
||||
func TestEmitPublishWarnings_WarnsAboutUntrackedWithAllowDirty(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
runGit(t, dir, "init", "-q")
|
||||
if err := os.WriteFile(filepath.Join(dir, "README.md"), []byte("hi"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
runGit(t, dir, "add", "README.md")
|
||||
runGit(t, dir, "commit", "-qm", "init")
|
||||
if err := os.WriteFile(filepath.Join(dir, "scratch.txt"), []byte("notes"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
t.Run("allowDirty=true surfaces untracked warning", func(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
if err := emitPublishWarnings(dir, true, &buf); err != nil {
|
||||
t.Fatalf("emitPublishWarnings: %v", err)
|
||||
}
|
||||
out := buf.String()
|
||||
if !strings.Contains(out, "scratch.txt") {
|
||||
t.Errorf("expected untracked-files warning to mention scratch.txt, got: %q", out)
|
||||
}
|
||||
if !strings.Contains(out, "NOT be in the archive") {
|
||||
t.Errorf("expected untracked-files warning fragment, got: %q", out)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("allowDirty=false aborts before untracked warning", func(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
err := emitPublishWarnings(dir, false, &buf)
|
||||
if err == nil {
|
||||
t.Fatal("expected dirty-tree error, got nil")
|
||||
}
|
||||
if !strings.Contains(err.Error(), "working tree dirty") {
|
||||
t.Errorf("expected dirty-tree error, got: %v", err)
|
||||
}
|
||||
if !strings.Contains(err.Error(), "--strict") {
|
||||
t.Errorf("expected dirty-tree error to reference --strict, got: %v", err)
|
||||
}
|
||||
if strings.Contains(buf.String(), "untracked files will NOT be in the archive") {
|
||||
t.Errorf("untracked-files warning should not fire on dirty-abort path, got: %q", buf.String())
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestWriteMod_PrivateTrueSerializes(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
path := filepath.Join(dir, "plugin.mod")
|
||||
m := &core.ModFile{Plugin: core.ModPlugin{
|
||||
Name: "myplugin",
|
||||
Scope: "themes",
|
||||
Version: "0.1.0",
|
||||
Private: true,
|
||||
}}
|
||||
if err := writeMod(path, m); err != nil {
|
||||
t.Fatalf("writeMod: %v", err)
|
||||
}
|
||||
got, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
t.Fatalf("read back: %v", err)
|
||||
}
|
||||
if !strings.Contains(string(got), "private = true") {
|
||||
t.Errorf("expected `private = true` line in plugin.mod, got:\n%s", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestWriteMod_PrivateFalseOmitted(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
path := filepath.Join(dir, "plugin.mod")
|
||||
m := &core.ModFile{Plugin: core.ModPlugin{
|
||||
Name: "publicthing",
|
||||
Scope: "themes",
|
||||
Version: "0.1.0",
|
||||
}}
|
||||
if err := writeMod(path, m); err != nil {
|
||||
t.Fatalf("writeMod: %v", err)
|
||||
}
|
||||
got, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
t.Fatalf("read back: %v", err)
|
||||
}
|
||||
if strings.Contains(string(got), "private") {
|
||||
t.Errorf("expected no `private` line, got:\n%s", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestParsePrivateCoord(t *testing.T) {
|
||||
cases := []struct {
|
||||
in string
|
||||
want string
|
||||
wantErr bool
|
||||
}{
|
||||
{in: "myplugin", want: "myplugin"},
|
||||
{in: "@private/myplugin", want: "myplugin"},
|
||||
{in: " myplugin ", want: "myplugin"},
|
||||
{in: "@themes/myplugin", wantErr: true},
|
||||
{in: "@private", wantErr: true},
|
||||
}
|
||||
for _, c := range cases {
|
||||
got, err := parsePrivateCoord(c.in)
|
||||
if c.wantErr {
|
||||
if err == nil {
|
||||
t.Errorf("parsePrivateCoord(%q) = %q, want error", c.in, got)
|
||||
}
|
||||
continue
|
||||
}
|
||||
if err != nil {
|
||||
t.Errorf("parsePrivateCoord(%q) err: %v", c.in, err)
|
||||
continue
|
||||
}
|
||||
if got != c.want {
|
||||
t.Errorf("parsePrivateCoord(%q) = %q, want %q", c.in, got, c.want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestMutateTags_AddRmSetClear(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
t.Chdir(dir)
|
||||
|
||||
must := func(err error) {
|
||||
t.Helper()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
// Seed plugin.mod with no tags.
|
||||
must(upsertPluginMod("themes", "darkpro", "Dark Pro", "Sleek dark theme", "theme", []string{}, nil, false))
|
||||
|
||||
// add
|
||||
must(mutateTags("add", []string{"dark", "agency"}))
|
||||
mod, err := readLocalMod()
|
||||
must(err)
|
||||
if len(mod.Plugin.Tags) != 2 || mod.Plugin.Tags[0] != "dark" || mod.Plugin.Tags[1] != "agency" {
|
||||
t.Errorf("after add: %v", mod.Plugin.Tags)
|
||||
}
|
||||
|
||||
// add (dedupe + normalise)
|
||||
must(mutateTags("add", []string{"Agency", "Serif"}))
|
||||
mod, _ = readLocalMod()
|
||||
if len(mod.Plugin.Tags) != 3 {
|
||||
t.Errorf("after dedupe add: %v", mod.Plugin.Tags)
|
||||
}
|
||||
|
||||
// rm
|
||||
must(mutateTags("rm", []string{"dark"}))
|
||||
mod, _ = readLocalMod()
|
||||
for _, tag := range mod.Plugin.Tags {
|
||||
if tag == "dark" {
|
||||
t.Errorf("after rm: dark still present: %v", mod.Plugin.Tags)
|
||||
}
|
||||
}
|
||||
|
||||
// set
|
||||
must(mutateTags("set", []string{"editorial"}))
|
||||
mod, _ = readLocalMod()
|
||||
if len(mod.Plugin.Tags) != 1 || mod.Plugin.Tags[0] != "editorial" {
|
||||
t.Errorf("after set: %v", mod.Plugin.Tags)
|
||||
}
|
||||
|
||||
// clear
|
||||
must(mutateTags("clear", nil))
|
||||
mod, _ = readLocalMod()
|
||||
if len(mod.Plugin.Tags) != 0 {
|
||||
t.Errorf("after clear: %v", mod.Plugin.Tags)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMutateTags_RejectsInvalidNoWrite(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
t.Chdir(dir)
|
||||
|
||||
if err := upsertPluginMod("themes", "x", "X", "", "theme", nil, []string{"dark"}, false); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := mutateTags("add", []string{"BAD SPACE"}); err == nil {
|
||||
t.Fatal("expected validation error")
|
||||
}
|
||||
mod, err := readLocalMod()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(mod.Plugin.Tags) != 1 || mod.Plugin.Tags[0] != "dark" {
|
||||
t.Errorf("tags mutated despite error: %v", mod.Plugin.Tags)
|
||||
}
|
||||
}
|
||||
|
||||
func runGit(t *testing.T, dir string, args ...string) {
|
||||
t.Helper()
|
||||
cmd := exec.Command("git", args...)
|
||||
cmd.Dir = dir
|
||||
cmd.Env = append(os.Environ(),
|
||||
"GIT_AUTHOR_NAME=t",
|
||||
"GIT_AUTHOR_EMAIL=t@t",
|
||||
"GIT_COMMITTER_NAME=t",
|
||||
"GIT_COMMITTER_EMAIL=t@t",
|
||||
)
|
||||
out, err := cmd.CombinedOutput()
|
||||
if err != nil {
|
||||
t.Fatalf("git %v: %v\n%s", args, err, out)
|
||||
}
|
||||
}
|
||||
22
cmd/ninja/cmd/root.go
Normal file
22
cmd/ninja/cmd/root.go
Normal file
@ -0,0 +1,22 @@
|
||||
package cmd
|
||||
|
||||
import "github.com/spf13/cobra"
|
||||
|
||||
func NewRoot() *cobra.Command {
|
||||
root := &cobra.Command{
|
||||
Use: "ninja",
|
||||
Short: "BlockNinja developer CLI",
|
||||
Long: "ninja is the developer-facing CLI for BlockNinja. First subcommand group: plugin.",
|
||||
}
|
||||
root.PersistentFlags().String("host", "", "Orchestrator base URL (default: from credentials or https://my.blockninjacms.com)")
|
||||
root.AddCommand(newVersionCmd())
|
||||
root.AddCommand(newLoginCmd())
|
||||
root.AddCommand(newLogoutCmd())
|
||||
root.AddCommand(newWhoamiCmd())
|
||||
root.AddCommand(newPluginCmd())
|
||||
root.AddCommand(newThemeCmd())
|
||||
root.AddCommand(newScopeCmd())
|
||||
root.AddCommand(newAccountCmd())
|
||||
root.AddCommand(newAbiCmd())
|
||||
return root
|
||||
}
|
||||
230
cmd/ninja/cmd/scope.go
Normal file
230
cmd/ninja/cmd/scope.go
Normal file
@ -0,0 +1,230 @@
|
||||
package cmd
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"context"
|
||||
"fmt"
|
||||
"os"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"connectrpc.com/connect"
|
||||
"github.com/spf13/cobra"
|
||||
|
||||
"git.dev.alexdunmow.com/block/cli/internal/creds"
|
||||
"git.dev.alexdunmow.com/block/cli/internal/orchclient"
|
||||
v1 "git.dev.alexdunmow.com/block/cli/internal/api/orchestrator/v1"
|
||||
)
|
||||
|
||||
func newScopeCmd() *cobra.Command {
|
||||
c := &cobra.Command{Use: "scope", Short: "Manage plugin scopes"}
|
||||
c.AddCommand(newScopeCreateCmd(), newScopeListCmd(), newScopeDefaultCmd())
|
||||
return c
|
||||
}
|
||||
|
||||
func newScopeCreateCmd() *cobra.Command {
|
||||
cmd := &cobra.Command{
|
||||
Use: "create [scope]",
|
||||
Short: "Create a new scope (organisation namespace for plugins)",
|
||||
Args: cobra.MaximumNArgs(1),
|
||||
RunE: func(c *cobra.Command, args []string) error {
|
||||
host, _ := c.Flags().GetString("host")
|
||||
cr, err := creds.Load()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
resolvedHost, hc, err := cr.Resolve(host)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
cli := orchclient.New(resolvedHost, hc.Token)
|
||||
ctx := context.Background()
|
||||
scanner := bufio.NewScanner(os.Stdin)
|
||||
|
||||
var slug string
|
||||
if len(args) > 0 {
|
||||
slug, err = parseScope(args[0])
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
} else {
|
||||
slug, err = promptScopeSlug(scanner)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
fmt.Printf("Display name [%s]: ", scopeAPISlug(slug))
|
||||
displayName := scopeAPISlug(slug)
|
||||
if scanner.Scan() {
|
||||
if v := strings.TrimSpace(scanner.Text()); v != "" {
|
||||
displayName = v
|
||||
}
|
||||
}
|
||||
|
||||
_, err = cli.Scope.CreateScope(ctx, connect.NewRequest(&v1.CreateScopeRequest{
|
||||
Slug: scopeAPISlug(slug),
|
||||
DisplayName: displayName,
|
||||
}))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
fmt.Printf("Created scope %s\n", slug)
|
||||
|
||||
fmt.Printf("Set %s as your default scope? [Y/n]: ", slug)
|
||||
if scanner.Scan() {
|
||||
ans := strings.ToLower(strings.TrimSpace(scanner.Text()))
|
||||
if ans == "" || ans == "y" || ans == "yes" {
|
||||
hc.DefaultScope = slug
|
||||
cr.Hosts[resolvedHost] = hc
|
||||
if err := cr.Save(); err != nil {
|
||||
fmt.Fprintf(os.Stderr, "warning: could not save default scope: %v\n", err)
|
||||
} else {
|
||||
fmt.Println("Default scope saved.")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
},
|
||||
}
|
||||
return cmd
|
||||
}
|
||||
|
||||
func promptScopeSlug(scanner *bufio.Scanner) (string, error) {
|
||||
fmt.Println("A scope is an organisation namespace for your plugins (e.g. @acme).")
|
||||
fmt.Println("It appears in plugin names like @acme/my-plugin.")
|
||||
fmt.Println()
|
||||
fmt.Print("Scope slug (lowercase letters, numbers, dashes): ")
|
||||
if !scanner.Scan() {
|
||||
return "", fmt.Errorf("cancelled")
|
||||
}
|
||||
return parseScope(scanner.Text())
|
||||
}
|
||||
|
||||
func newScopeDefaultCmd() *cobra.Command {
|
||||
cmd := &cobra.Command{
|
||||
Use: "default",
|
||||
Short: "Show or change the default scope",
|
||||
RunE: func(c *cobra.Command, _ []string) error {
|
||||
host, _ := c.Flags().GetString("host")
|
||||
cr, err := creds.Load()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
_, hc, err := cr.Resolve(host)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if hc.DefaultScope == "" {
|
||||
fmt.Println("No default scope set. Run: ninja scope default set")
|
||||
} else {
|
||||
fmt.Println(hc.DefaultScope)
|
||||
}
|
||||
return nil
|
||||
},
|
||||
}
|
||||
cmd.AddCommand(newScopeDefaultSetCmd())
|
||||
return cmd
|
||||
}
|
||||
|
||||
func newScopeDefaultSetCmd() *cobra.Command {
|
||||
return &cobra.Command{
|
||||
Use: "set",
|
||||
Short: "Pick a default scope from your scopes",
|
||||
RunE: func(c *cobra.Command, _ []string) error {
|
||||
host, _ := c.Flags().GetString("host")
|
||||
cr, err := creds.Load()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
resolvedHost, hc, err := cr.Resolve(host)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
cli := orchclient.New(resolvedHost, hc.Token)
|
||||
ctx := context.Background()
|
||||
|
||||
scopes, err := cli.Scope.ListMyScopes(ctx, connect.NewRequest(&v1.ListMyScopesRequest{}))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if len(scopes.Msg.Scopes) == 0 {
|
||||
fmt.Println("No scopes yet. Create one with: ninja scope create")
|
||||
return nil
|
||||
}
|
||||
|
||||
fmt.Println("Your scopes:")
|
||||
for i, s := range scopes.Msg.Scopes {
|
||||
marker := ""
|
||||
if "@"+s.Slug == hc.DefaultScope {
|
||||
marker = " (current)"
|
||||
}
|
||||
fmt.Printf(" %d. @%s — %s%s\n", i+1, s.Slug, s.DisplayName, marker)
|
||||
}
|
||||
fmt.Println()
|
||||
|
||||
scanner := bufio.NewScanner(os.Stdin)
|
||||
fmt.Print("Select a scope: ")
|
||||
if !scanner.Scan() {
|
||||
return fmt.Errorf("cancelled")
|
||||
}
|
||||
input := strings.TrimSpace(scanner.Text())
|
||||
if input == "" {
|
||||
return fmt.Errorf("cancelled")
|
||||
}
|
||||
|
||||
var scope string
|
||||
if n, err := strconv.Atoi(input); err == nil && n >= 1 && n <= len(scopes.Msg.Scopes) {
|
||||
scope = "@" + scopes.Msg.Scopes[n-1].Slug
|
||||
} else {
|
||||
return fmt.Errorf("invalid selection: %s", input)
|
||||
}
|
||||
|
||||
hc.DefaultScope = scope
|
||||
cr.Hosts[resolvedHost] = hc
|
||||
if err := cr.Save(); err != nil {
|
||||
return err
|
||||
}
|
||||
fmt.Printf("Default scope set to %s\n", scope)
|
||||
return nil
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func newScopeListCmd() *cobra.Command {
|
||||
return &cobra.Command{
|
||||
Use: "list",
|
||||
Short: "List your scopes",
|
||||
RunE: func(c *cobra.Command, _ []string) error {
|
||||
host, _ := c.Flags().GetString("host")
|
||||
cr, err := creds.Load()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
resolvedHost, hc, err := cr.Resolve(host)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
cli := orchclient.New(resolvedHost, hc.Token)
|
||||
ctx := context.Background()
|
||||
|
||||
scopes, err := cli.Scope.ListMyScopes(ctx, connect.NewRequest(&v1.ListMyScopesRequest{}))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if len(scopes.Msg.Scopes) == 0 {
|
||||
fmt.Println("No scopes yet. Create one with: ninja scope create")
|
||||
return nil
|
||||
}
|
||||
for _, s := range scopes.Msg.Scopes {
|
||||
marker := ""
|
||||
if "@"+s.Slug == hc.DefaultScope {
|
||||
marker = " (default)"
|
||||
}
|
||||
fmt.Printf("@%s — %s%s\n", s.Slug, s.DisplayName, marker)
|
||||
}
|
||||
return nil
|
||||
},
|
||||
}
|
||||
}
|
||||
8
cmd/ninja/cmd/testdata/capfixture/main.go
vendored
Normal file
8
cmd/ninja/cmd/testdata/capfixture/main.go
vendored
Normal file
@ -0,0 +1,8 @@
|
||||
//go:build wasip1
|
||||
|
||||
package main
|
||||
|
||||
import "git.dev.alexdunmow.com/block/core/plugin/wasmguest"
|
||||
|
||||
func init() { wasmguest.Serve(Registration) }
|
||||
func main() {} // never called — reactor mode
|
||||
6
cmd/ninja/cmd/testdata/capfixture/plugin.mod
vendored
Normal file
6
cmd/ninja/cmd/testdata/capfixture/plugin.mod
vendored
Normal file
@ -0,0 +1,6 @@
|
||||
[plugin]
|
||||
name = "capfixture"
|
||||
scope = "@blockninja"
|
||||
version = "0.0.1"
|
||||
description = "Negative fixture: Register hits a host capability at describe time"
|
||||
kind = "plugin"
|
||||
38
cmd/ninja/cmd/testdata/capfixture/registration.go
vendored
Normal file
38
cmd/ninja/cmd/testdata/capfixture/registration.go
vendored
Normal file
@ -0,0 +1,38 @@
|
||||
// Package main is a NEGATIVE build fixture: its Register hook reaches a host
|
||||
// capability (a db.* call) at describe time, which is illegal — DESCRIBE runs
|
||||
// with no live host. `ninja plugin build` must surface an actionable error
|
||||
// naming the offending call rather than hanging or crashing.
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"fmt"
|
||||
|
||||
// Registers the "bnwasm" database/sql driver (its init runs sql.Register).
|
||||
_ "git.dev.alexdunmow.com/block/core/plugin/wasmguest/bnwasm"
|
||||
|
||||
"git.dev.alexdunmow.com/block/core/blocks"
|
||||
"git.dev.alexdunmow.com/block/core/plugin"
|
||||
"git.dev.alexdunmow.com/block/core/templates"
|
||||
)
|
||||
|
||||
var Registration = plugin.PluginRegistration{
|
||||
Name: "capfixture",
|
||||
Version: "0.0.1",
|
||||
Register: func(_ templates.TemplateRegistry, _ blocks.BlockRegistry) error {
|
||||
// Illegal describe-time capability use: query the host DB from
|
||||
// Register. Over the packer's failing host stub this returns an error
|
||||
// naming "db.query".
|
||||
db, err := sql.Open("bnwasm", "")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer func() { _ = db.Close() }()
|
||||
var n int
|
||||
if err := db.QueryRowContext(context.Background(), "SELECT 1").Scan(&n); err != nil {
|
||||
return fmt.Errorf("describe-time db probe: %w", err)
|
||||
}
|
||||
return nil
|
||||
},
|
||||
}
|
||||
8
cmd/ninja/cmd/testdata/fixture/main.go
vendored
Normal file
8
cmd/ninja/cmd/testdata/fixture/main.go
vendored
Normal file
@ -0,0 +1,8 @@
|
||||
//go:build wasip1
|
||||
|
||||
package main
|
||||
|
||||
import "git.dev.alexdunmow.com/block/core/plugin/wasmguest"
|
||||
|
||||
func init() { wasmguest.Serve(Registration) }
|
||||
func main() {} // never called — reactor mode
|
||||
8
cmd/ninja/cmd/testdata/fixture/plugin.mod
vendored
Normal file
8
cmd/ninja/cmd/testdata/fixture/plugin.mod
vendored
Normal file
@ -0,0 +1,8 @@
|
||||
[plugin]
|
||||
name = "wasmfixture"
|
||||
display_name = "Wasm Fixture"
|
||||
scope = "@blockninja"
|
||||
version = "0.0.1"
|
||||
description = "WO-WZ-002 acceptance fixture: one block, one template, one admin page"
|
||||
kind = "plugin"
|
||||
data_dir = true
|
||||
97
cmd/ninja/cmd/testdata/fixture/registration.go
vendored
Normal file
97
cmd/ninja/cmd/testdata/fixture/registration.go
vendored
Normal file
@ -0,0 +1,97 @@
|
||||
// Package main is the WO-WZ-002 acceptance fixture: a minimal plugin with
|
||||
// one block, one template, and one admin page, compiled to wasm with only
|
||||
// the wasmguest boilerplate (main.go).
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"io"
|
||||
"strings"
|
||||
|
||||
"git.dev.alexdunmow.com/block/core/blocks"
|
||||
"git.dev.alexdunmow.com/block/core/plugin"
|
||||
"git.dev.alexdunmow.com/block/core/templates"
|
||||
)
|
||||
|
||||
// capReport is populated by the Load hook from capability calls, then
|
||||
// surfaced through the greeting block ({"report": true}). It is the runtime
|
||||
// proof that deps.Content / deps.Settings / deps.Bridge cross the wasm ABI
|
||||
// end-to-end through the guest capability stubs (WO-WZ-003 acceptance).
|
||||
var capReport string
|
||||
|
||||
// Registration is the fixture's plugin registration — the same shape a .so
|
||||
// plugin exports, untouched by the wasm migration.
|
||||
var Registration = plugin.PluginRegistration{
|
||||
Name: "wasmfixture",
|
||||
Version: "0.0.1",
|
||||
Register: func(tr templates.TemplateRegistry, br blocks.BlockRegistry) error {
|
||||
br.Register(blocks.BlockMeta{
|
||||
Key: "greeting",
|
||||
Title: "Greeting",
|
||||
Description: "Renders a greeting",
|
||||
Category: blocks.CategoryContent,
|
||||
}, func(ctx context.Context, content map[string]any) string {
|
||||
if boom, _ := content["boom"].(bool); boom {
|
||||
panic("fixture kaboom")
|
||||
}
|
||||
if report, _ := content["report"].(bool); report {
|
||||
return "<p>capreport:" + capReport + "</p>"
|
||||
}
|
||||
name, _ := content["name"].(string)
|
||||
if name == "" {
|
||||
name = "world"
|
||||
}
|
||||
if powered, _ := content["powered"].(bool); powered {
|
||||
// Powered path: hand the host a template + data instead of final
|
||||
// HTML, so the host renders it (pongo2) after this call returns.
|
||||
return blocks.PoweredBlock("<p>hello {{ name }}</p>", map[string]any{"name": name})
|
||||
}
|
||||
return fmt.Sprintf("<p>hello %s</p>", name)
|
||||
})
|
||||
// Custom template tag + filter the host wires from manifest.declared_tags
|
||||
// / declared_filters, invoked via HOOK_RENDER_TAG / HOOK_APPLY_FILTER.
|
||||
blocks.RegisterTag("shout", func(args map[string]any, rctx blocks.RenderContext) (string, error) {
|
||||
msg, _ := args["msg"].(string)
|
||||
return "<strong>" + strings.ToUpper(msg) + "</strong>", nil
|
||||
})
|
||||
blocks.RegisterFilter("exclaim", func(input string, args map[string]any) (string, error) {
|
||||
return input + "!", nil
|
||||
})
|
||||
return tr.Register("wasmfixture-page", func(ctx context.Context, doc map[string]any) templates.HTMLComponent {
|
||||
title, _ := doc["title"].(string)
|
||||
return htmlString("<!doctype html><title>" + title + "</title>")
|
||||
})
|
||||
},
|
||||
// Load exercises the guest capability stubs exactly as a real plugin's
|
||||
// service code does — unchanged calls against deps.Content / deps.Settings
|
||||
// / deps.Bridge — proving they compile and cross the ABI for wasip1.
|
||||
Load: func(deps plugin.CoreServices) error {
|
||||
page, err := deps.Content.GetPage(context.Background(), "about")
|
||||
if err != nil {
|
||||
capReport = "content-err:" + err.Error()
|
||||
return nil
|
||||
}
|
||||
site, err := deps.Settings.GetSiteSettings(context.Background())
|
||||
if err != nil {
|
||||
capReport = "settings-err:" + err.Error()
|
||||
return nil
|
||||
}
|
||||
svc := deps.Bridge.GetService("other", "search") // cannot cross; expected nil
|
||||
capReport = fmt.Sprintf("page=%s site=%v bridge_nil=%t",
|
||||
page.Title, site["site_name"], svc == nil)
|
||||
return nil
|
||||
},
|
||||
AdminPages: func() []plugin.AdminPage {
|
||||
return []plugin.AdminPage{{
|
||||
Key: "wasmfixture", Title: "Wasm Fixture", Icon: "flask", Route: "/admin/wasmfixture",
|
||||
}}
|
||||
},
|
||||
}
|
||||
|
||||
type htmlString string
|
||||
|
||||
func (s htmlString) Render(_ context.Context, w io.Writer) error {
|
||||
_, err := io.WriteString(w, string(s))
|
||||
return err
|
||||
}
|
||||
108
cmd/ninja/cmd/theme.go
Normal file
108
cmd/ninja/cmd/theme.go
Normal file
@ -0,0 +1,108 @@
|
||||
package cmd
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"os"
|
||||
"time"
|
||||
|
||||
"github.com/spf13/cobra"
|
||||
|
||||
core "git.dev.alexdunmow.com/block/core/plugin"
|
||||
|
||||
"git.dev.alexdunmow.com/block/cli/internal/shot"
|
||||
)
|
||||
|
||||
func newThemeCmd() *cobra.Command {
|
||||
c := &cobra.Command{Use: "theme", Short: "Theme authoring helpers (preview screenshots)"}
|
||||
c.AddCommand(newThemeScreenshotCmd())
|
||||
return c
|
||||
}
|
||||
|
||||
func newThemeScreenshotCmd() *cobra.Command {
|
||||
var gallery, slug, out, mobileOut, themeName, waitSelector string
|
||||
var mobile bool
|
||||
var width, height int
|
||||
cmd := &cobra.Command{
|
||||
Use: "screenshot",
|
||||
Short: "Render this theme's showcase page and write preview.png into the repo",
|
||||
Long: `screenshot builds the gallery URL for this theme's showcase page
|
||||
(rendered via the CMS render-only ?preview_template override), drives a headless
|
||||
Chromium against it, and writes the captured PNG into the theme repo (preview.png,
|
||||
git-tracked — the source of truth a human may later replace).
|
||||
|
||||
The theme name defaults to plugin.mod's name in the current directory. Point
|
||||
--gallery at the gallery CMS site that has this theme's .so loaded and the
|
||||
showcase content seeded. --host selects the orchestrator (defaults to PROD); the
|
||||
gallery URL is independent of --host but the flag is accepted for parity with
|
||||
the rest of the CLI.`,
|
||||
RunE: func(c *cobra.Command, _ []string) error {
|
||||
if themeName == "" {
|
||||
modBytes, err := os.ReadFile("plugin.mod")
|
||||
if err != nil {
|
||||
return fmt.Errorf("read plugin.mod (run from the theme repo, or pass --theme): %w", err)
|
||||
}
|
||||
mod, err := core.ParseModFull(modBytes)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if mod.Plugin.Kind != "theme" {
|
||||
return fmt.Errorf("plugin.mod kind = %q, want theme", mod.Plugin.Kind)
|
||||
}
|
||||
themeName = mod.Plugin.Name
|
||||
}
|
||||
if gallery == "" {
|
||||
return fmt.Errorf("--gallery is required (the gallery CMS site base, e.g. https://showcase.localdev.blockninjacms.com)")
|
||||
}
|
||||
|
||||
ctx := context.Background()
|
||||
|
||||
desktopURL := shot.PreviewURL(gallery, slug, themeName)
|
||||
fmt.Fprintf(os.Stderr, "capturing desktop: %s\n", desktopURL)
|
||||
png, err := shot.Capture(ctx, shot.Options{
|
||||
URL: desktopURL,
|
||||
Width: width,
|
||||
Height: height,
|
||||
WaitSelector: waitSelector,
|
||||
Timeout: 45 * time.Second,
|
||||
})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err := os.WriteFile(out, png, 0o644); err != nil {
|
||||
return fmt.Errorf("write %s: %w", out, err)
|
||||
}
|
||||
fmt.Printf("wrote %s (%d bytes)\n", out, len(png))
|
||||
|
||||
if mobile {
|
||||
mURL := shot.PreviewURL(gallery, slug, themeName)
|
||||
fmt.Fprintf(os.Stderr, "capturing mobile: %s\n", mURL)
|
||||
mpng, err := shot.Capture(ctx, shot.Options{
|
||||
URL: mURL,
|
||||
Width: 390,
|
||||
Height: 844,
|
||||
WaitSelector: waitSelector,
|
||||
Timeout: 45 * time.Second,
|
||||
})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err := os.WriteFile(mobileOut, mpng, 0o644); err != nil {
|
||||
return fmt.Errorf("write %s: %w", mobileOut, err)
|
||||
}
|
||||
fmt.Printf("wrote %s (%d bytes)\n", mobileOut, len(mpng))
|
||||
}
|
||||
return nil
|
||||
},
|
||||
}
|
||||
cmd.Flags().StringVar(&gallery, "gallery", "", "Gallery CMS site base URL (has this theme loaded + showcase seeded)")
|
||||
cmd.Flags().StringVar(&slug, "slug", "/", "Showcase page slug to capture")
|
||||
cmd.Flags().StringVar(&out, "out", "preview.png", "Output path for the desktop screenshot (git-tracked in the theme repo)")
|
||||
cmd.Flags().StringVar(&mobileOut, "mobile-out", "preview-mobile.png", "Output path for the mobile screenshot")
|
||||
cmd.Flags().StringVar(&themeName, "theme", "", "Theme key to preview (default: plugin.mod name)")
|
||||
cmd.Flags().StringVar(&waitSelector, "wait", "section", "CSS selector to wait for before capturing")
|
||||
cmd.Flags().BoolVar(&mobile, "mobile", false, "Also capture preview-mobile.png at a phone viewport")
|
||||
cmd.Flags().IntVar(&width, "width", 1440, "Desktop viewport width")
|
||||
cmd.Flags().IntVar(&height, "height", 900, "Desktop viewport height")
|
||||
return cmd
|
||||
}
|
||||
36
cmd/ninja/cmd/theme_test.go
Normal file
36
cmd/ninja/cmd/theme_test.go
Normal file
@ -0,0 +1,36 @@
|
||||
package cmd
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestThemeScreenshotCommandRegistered(t *testing.T) {
|
||||
root := NewRoot()
|
||||
theme, _, err := root.Find([]string{"theme", "screenshot"})
|
||||
if err != nil {
|
||||
t.Fatalf("find theme screenshot: %v", err)
|
||||
}
|
||||
if theme.Name() != "screenshot" {
|
||||
t.Fatalf("resolved command = %q, want screenshot", theme.Name())
|
||||
}
|
||||
}
|
||||
|
||||
func TestThemeScreenshotHasGalleryAndMobileFlags(t *testing.T) {
|
||||
root := NewRoot()
|
||||
cmd, _, _ := root.Find([]string{"theme", "screenshot"})
|
||||
for _, name := range []string{"gallery", "mobile", "out", "slug"} {
|
||||
if cmd.Flags().Lookup(name) == nil {
|
||||
t.Errorf("missing --%s flag", name)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestThemeScreenshotDefaultOutIsPreviewPng(t *testing.T) {
|
||||
root := NewRoot()
|
||||
cmd, _, _ := root.Find([]string{"theme", "screenshot"})
|
||||
out, _ := cmd.Flags().GetString("out")
|
||||
if !strings.HasSuffix(out, "preview.png") {
|
||||
t.Fatalf("default --out = %q, want it to end with preview.png", out)
|
||||
}
|
||||
}
|
||||
19
cmd/ninja/cmd/version.go
Normal file
19
cmd/ninja/cmd/version.go
Normal file
@ -0,0 +1,19 @@
|
||||
package cmd
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"github.com/spf13/cobra"
|
||||
)
|
||||
|
||||
var Version = "dev"
|
||||
|
||||
func newVersionCmd() *cobra.Command {
|
||||
return &cobra.Command{
|
||||
Use: "version",
|
||||
Short: "Print ninja version",
|
||||
Run: func(_ *cobra.Command, _ []string) {
|
||||
fmt.Println("ninja", Version)
|
||||
},
|
||||
}
|
||||
}
|
||||
15
cmd/ninja/main.go
Normal file
15
cmd/ninja/main.go
Normal file
@ -0,0 +1,15 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os"
|
||||
|
||||
"git.dev.alexdunmow.com/block/cli/cmd/ninja/cmd"
|
||||
)
|
||||
|
||||
func main() {
|
||||
if err := cmd.NewRoot().Execute(); err != nil {
|
||||
fmt.Fprintln(os.Stderr, "Error:", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
}
|
||||
34
go.mod
Normal file
34
go.mod
Normal file
@ -0,0 +1,34 @@
|
||||
module git.dev.alexdunmow.com/block/cli
|
||||
|
||||
go 1.26.4
|
||||
|
||||
require (
|
||||
connectrpc.com/connect v1.20.0
|
||||
git.dev.alexdunmow.com/block/core v0.18.2
|
||||
github.com/chromedp/chromedp v0.15.1
|
||||
github.com/klauspost/compress v1.18.6
|
||||
github.com/spf13/cobra v1.10.2
|
||||
github.com/tetratelabs/wazero v1.12.0
|
||||
google.golang.org/protobuf v1.36.11
|
||||
gopkg.in/yaml.v3 v3.0.1
|
||||
)
|
||||
|
||||
require (
|
||||
github.com/BurntSushi/toml v1.6.0 // indirect
|
||||
github.com/chromedp/cdproto v0.0.0-20260321001828-e3e3800016bc // indirect
|
||||
github.com/chromedp/sysutil v1.1.0 // indirect
|
||||
github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433 // indirect
|
||||
github.com/gobwas/httphead v0.1.0 // indirect
|
||||
github.com/gobwas/pool v0.2.1 // indirect
|
||||
github.com/gobwas/ws v1.4.0 // indirect
|
||||
github.com/google/uuid v1.6.0 // indirect
|
||||
github.com/inconshreveable/mousetrap v1.1.0 // indirect
|
||||
github.com/jackc/pgpassfile v1.0.0 // indirect
|
||||
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
|
||||
github.com/jackc/pgx/v5 v5.9.2 // indirect
|
||||
github.com/kr/text v0.2.0 // indirect
|
||||
github.com/spf13/pflag v1.0.9 // indirect
|
||||
golang.org/x/mod v0.34.0 // indirect
|
||||
golang.org/x/sys v0.44.0 // indirect
|
||||
golang.org/x/text v0.36.0 // indirect
|
||||
)
|
||||
83
go.sum
Normal file
83
go.sum
Normal file
@ -0,0 +1,83 @@
|
||||
connectrpc.com/connect v1.20.0 h1:6TNDAB+WeNd2uolWNlYczB5E0KNNaVMNUEx8JEUsPmQ=
|
||||
connectrpc.com/connect v1.20.0/go.mod h1:A2ygJrukXwWy32vkCAAHNVguZrqZ+jeZ9rGRnGR4dN4=
|
||||
git.dev.alexdunmow.com/block/core v0.18.2 h1:+3OfZ424yoc1k1CucXYARk8TBkh8Z693HRkhf5Ci2wU=
|
||||
git.dev.alexdunmow.com/block/core v0.18.2/go.mod h1:GGuUu826AoJepC/hKLGJ7BX3PQaDss9ueCT0se6Ao2w=
|
||||
github.com/BurntSushi/toml v1.6.0 h1:dRaEfpa2VI55EwlIW72hMRHdWouJeRF7TPYhI+AUQjk=
|
||||
github.com/BurntSushi/toml v1.6.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=
|
||||
github.com/chromedp/cdproto v0.0.0-20260321001828-e3e3800016bc h1:wkN/LMi5vc60pBRWx6qpbk/aEvq3/ZVNpnMvsw8PVVU=
|
||||
github.com/chromedp/cdproto v0.0.0-20260321001828-e3e3800016bc/go.mod h1:cbyjALe67vDvlvdiG9369P8w5U2w6IshwtyD2f2Tvag=
|
||||
github.com/chromedp/chromedp v0.15.1 h1:EJWiPm7BNqDqjYy6U0lTSL5wNH+iNt9GjC3a4gfjNyQ=
|
||||
github.com/chromedp/chromedp v0.15.1/go.mod h1:CdTHtUqD/dqaFw/cvFWtTydoEQS44wLBuwbMR9EkOY4=
|
||||
github.com/chromedp/sysutil v1.1.0 h1:PUFNv5EcprjqXZD9nJb9b/c9ibAbxiYo4exNWZyipwM=
|
||||
github.com/chromedp/sysutil v1.1.0/go.mod h1:WiThHUdltqCNKGc4gaU50XgYjwjYIhKWoHGPTUfWTJ8=
|
||||
github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
|
||||
github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
|
||||
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
|
||||
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
|
||||
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
|
||||
github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433 h1:vymEbVwYFP/L05h5TKQxvkXoKxNvTpjxYKdF1Nlwuao=
|
||||
github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433/go.mod h1:tphK2c80bpPhMOI4v6bIc2xWywPfbqi1Z06+RcrMkDg=
|
||||
github.com/gobwas/httphead v0.1.0 h1:exrUm0f4YX0L7EBwZHuCF4GDp8aJfVeBrlLQrs6NqWU=
|
||||
github.com/gobwas/httphead v0.1.0/go.mod h1:O/RXo79gxV8G+RqlR/otEwx4Q36zl9rqC5u12GKvMCM=
|
||||
github.com/gobwas/pool v0.2.1 h1:xfeeEhW7pwmX8nuLVlqbzVc7udMDrwetjEv+TZIz1og=
|
||||
github.com/gobwas/pool v0.2.1/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
|
||||
github.com/gobwas/ws v1.4.0 h1:CTaoG1tojrh4ucGPcoJFiAQUAsEWekEWvLy7GsVNqGs=
|
||||
github.com/gobwas/ws v1.4.0/go.mod h1:G3gNqMNtPppf5XUz7O4shetPpcZ1VJ7zt18dlUeakrc=
|
||||
github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
|
||||
github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
|
||||
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
|
||||
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
|
||||
github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
|
||||
github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
|
||||
github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
|
||||
github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
|
||||
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
|
||||
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
|
||||
github.com/jackc/pgx/v5 v5.9.2 h1:3ZhOzMWnR4yJ+RW1XImIPsD1aNSz4T4fyP7zlQb56hw=
|
||||
github.com/jackc/pgx/v5 v5.9.2/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4=
|
||||
github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
|
||||
github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
|
||||
github.com/klauspost/compress v1.18.6 h1:2jupLlAwFm95+YDR+NwD2MEfFO9d4z4Prjl1XXDjuao=
|
||||
github.com/klauspost/compress v1.18.6/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ=
|
||||
github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
|
||||
github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=
|
||||
github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
|
||||
github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
|
||||
github.com/ledongthuc/pdf v0.0.0-20220302134840-0c2507a12d80 h1:6Yzfa6GP0rIo/kULo2bwGEkFvCePZ3qHDDTC3/J9Swo=
|
||||
github.com/ledongthuc/pdf v0.0.0-20220302134840-0c2507a12d80/go.mod h1:imJHygn/1yfhB7XSJJKlFZKl/J+dCPAknuiaGOshXAs=
|
||||
github.com/orisano/pixelmatch v0.0.0-20220722002657-fb0b55479cde h1:x0TT0RDC7UhAVbbWWBzr41ElhJx5tXPWkIHA2HWPRuw=
|
||||
github.com/orisano/pixelmatch v0.0.0-20220722002657-fb0b55479cde/go.mod h1:nZgzbfBr3hhjoZnS66nKrHmduYNpc34ny7RK4z5/HM0=
|
||||
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
|
||||
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
|
||||
github.com/rogpeppe/go-internal v1.15.0 h1:D0RCU5rMAp+SpgkiNdrjfJ+LX4J1M32V2NeCY7EJ6hc=
|
||||
github.com/rogpeppe/go-internal v1.15.0/go.mod h1:DrUVZyrJU+txYW5/1kwtXQSMFio52ZOxX7yM1VHvnxs=
|
||||
github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
|
||||
github.com/spf13/cobra v1.10.2 h1:DMTTonx5m65Ic0GOoRY2c16WCbHxOOw6xxezuLaBpcU=
|
||||
github.com/spf13/cobra v1.10.2/go.mod h1:7C1pvHqHw5A4vrJfjNwvOdzYu0Gml16OCs2GRiTUUS4=
|
||||
github.com/spf13/pflag v1.0.9 h1:9exaQaMOCwffKiiiYk6/BndUBv+iRViNW+4lEMi0PvY=
|
||||
github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
|
||||
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
|
||||
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
|
||||
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
|
||||
github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
|
||||
github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
|
||||
github.com/tetratelabs/wazero v1.12.0 h1:DuWcpNu/FzgEXgGBDp8J1Spc+CWOvvtvVyjKlaZopYU=
|
||||
github.com/tetratelabs/wazero v1.12.0/go.mod h1:LvKtzl2RqO4gyF27BiXU+nKAjcV8f38U+kP/q2vgxh0=
|
||||
go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
|
||||
golang.org/x/mod v0.34.0 h1:xIHgNUUnW6sYkcM5Jleh05DvLOtwc6RitGHbDk4akRI=
|
||||
golang.org/x/mod v0.34.0/go.mod h1:ykgH52iCZe79kzLLMhyCUzhMci+nQj+0XkbXpNYtVjY=
|
||||
golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
|
||||
golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
|
||||
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/sys v0.44.0 h1:ildZl3J4uzeKP07r2F++Op7E9B29JRUy+a27EibtBTQ=
|
||||
golang.org/x/sys v0.44.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
|
||||
golang.org/x/text v0.36.0 h1:JfKh3XmcRPqZPKevfXVpI1wXPTqbkE5f7JA92a55Yxg=
|
||||
golang.org/x/text v0.36.0/go.mod h1:NIdBknypM8iqVmPiuco0Dh6P5Jcdk8lJL0CUebqK164=
|
||||
google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
|
||||
google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
|
||||
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
|
||||
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
|
||||
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
|
||||
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
|
||||
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
|
||||
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
|
||||
File diff suppressed because it is too large
Load Diff
4466
internal/api/orchestrator/v1/plugin_registry.pb.go
Normal file
4466
internal/api/orchestrator/v1/plugin_registry.pb.go
Normal file
File diff suppressed because it is too large
Load Diff
56
internal/archive/archive.go
Normal file
56
internal/archive/archive.go
Normal file
@ -0,0 +1,56 @@
|
||||
package archive
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"io"
|
||||
"os/exec"
|
||||
"strings"
|
||||
|
||||
"github.com/klauspost/compress/zstd"
|
||||
)
|
||||
|
||||
// BuildSourceArchive captures the working tree as `tar.zst` bytes.
|
||||
//
|
||||
// When the working tree is clean it archives HEAD. When it's dirty
|
||||
// (modified or staged tracked files), it archives a temporary stash
|
||||
// object so the dirty state is what ships — callers that want
|
||||
// HEAD-only behaviour should reject dirty trees before calling.
|
||||
// Untracked files are never included regardless of state.
|
||||
func BuildSourceArchive(repoDir string) ([]byte, error) {
|
||||
stashCmd := exec.Command("git", "stash", "create")
|
||||
stashCmd.Dir = repoDir
|
||||
var stashOut, stashErr bytes.Buffer
|
||||
stashCmd.Stdout = &stashOut
|
||||
stashCmd.Stderr = &stashErr
|
||||
if err := stashCmd.Run(); err != nil {
|
||||
return nil, fmt.Errorf("git stash create: %v: %s", err, stashErr.String())
|
||||
}
|
||||
treeish := "HEAD"
|
||||
if sha := strings.TrimSpace(stashOut.String()); sha != "" {
|
||||
treeish = sha
|
||||
}
|
||||
|
||||
cmd := exec.Command("git", "archive", "--format=tar", treeish)
|
||||
cmd.Dir = repoDir
|
||||
var tarOut, stderr bytes.Buffer
|
||||
cmd.Stdout = &tarOut
|
||||
cmd.Stderr = &stderr
|
||||
if err := cmd.Run(); err != nil {
|
||||
return nil, fmt.Errorf("git archive: %v: %s", err, stderr.String())
|
||||
}
|
||||
|
||||
var compressed bytes.Buffer
|
||||
enc, err := zstd.NewWriter(&compressed, zstd.WithEncoderLevel(zstd.SpeedDefault))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if _, err := io.Copy(enc, &tarOut); err != nil {
|
||||
_ = enc.Close()
|
||||
return nil, err
|
||||
}
|
||||
if err := enc.Close(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return compressed.Bytes(), nil
|
||||
}
|
||||
208
internal/archive/archive_test.go
Normal file
208
internal/archive/archive_test.go
Normal file
@ -0,0 +1,208 @@
|
||||
package archive
|
||||
|
||||
import (
|
||||
"archive/tar"
|
||||
"bytes"
|
||||
"io"
|
||||
"os"
|
||||
"os/exec"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/klauspost/compress/zstd"
|
||||
)
|
||||
|
||||
func TestBuildSourceArchive_RoundTrip(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
run := func(name string, args ...string) {
|
||||
t.Helper()
|
||||
cmd := exec.Command(name, args...)
|
||||
cmd.Dir = dir
|
||||
cmd.Env = append(os.Environ(),
|
||||
"GIT_AUTHOR_NAME=t",
|
||||
"GIT_AUTHOR_EMAIL=t@t",
|
||||
"GIT_COMMITTER_NAME=t",
|
||||
"GIT_COMMITTER_EMAIL=t@t",
|
||||
)
|
||||
out, err := cmd.CombinedOutput()
|
||||
if err != nil {
|
||||
t.Fatalf("%s %v: %v\n%s", name, args, err, out)
|
||||
}
|
||||
}
|
||||
run("git", "init", "-q")
|
||||
if err := os.WriteFile(filepath.Join(dir, "plugin.mod"),
|
||||
[]byte("[plugin]\nname=\"x\"\nscope=\"@s\"\nversion=\"0.1.0\"\n"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := os.WriteFile(filepath.Join(dir, "ignored.log"), []byte("nope"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := os.WriteFile(filepath.Join(dir, ".gitignore"), []byte("ignored.log\n"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
run("git", "add", "plugin.mod", ".gitignore")
|
||||
run("git", "commit", "-qm", "init")
|
||||
|
||||
zstdBytes, err := BuildSourceArchive(dir)
|
||||
if err != nil {
|
||||
t.Fatalf("BuildSourceArchive: %v", err)
|
||||
}
|
||||
if len(zstdBytes) == 0 {
|
||||
t.Fatal("empty archive")
|
||||
}
|
||||
|
||||
dec, err := zstd.NewReader(bytes.NewReader(zstdBytes))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer dec.Close()
|
||||
tr := tar.NewReader(dec)
|
||||
got := map[string]string{}
|
||||
for {
|
||||
hdr, err := tr.Next()
|
||||
if err == io.EOF {
|
||||
break
|
||||
}
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
buf, err := io.ReadAll(tr)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
got[hdr.Name] = string(buf)
|
||||
}
|
||||
if _, ok := got["plugin.mod"]; !ok {
|
||||
t.Errorf("expected plugin.mod in archive, got %v", keys(got))
|
||||
}
|
||||
if _, ok := got["ignored.log"]; ok {
|
||||
t.Errorf("ignored.log should not be in archive (gitignored + untracked)")
|
||||
}
|
||||
}
|
||||
|
||||
func keys(m map[string]string) []string {
|
||||
out := make([]string, 0, len(m))
|
||||
for k := range m {
|
||||
out = append(out, k)
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func TestBuildSourceArchive_DirtyTreeShipsWorkingCopy(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
runGitArchive(t, dir, "init", "-q")
|
||||
modPath := filepath.Join(dir, "plugin.mod")
|
||||
if err := os.WriteFile(modPath,
|
||||
[]byte("[plugin]\nname=\"x\"\nscope=\"@s\"\nversion=\"0.1.0\"\n"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
runGitArchive(t, dir, "add", "plugin.mod")
|
||||
runGitArchive(t, dir, "commit", "-qm", "init")
|
||||
|
||||
dirtyContents := []byte("[plugin]\nname=\"x\"\nscope=\"@s\"\nversion=\"0.1.1\"\n")
|
||||
if err := os.WriteFile(modPath, dirtyContents, 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
zstdBytes, err := BuildSourceArchive(dir)
|
||||
if err != nil {
|
||||
t.Fatalf("BuildSourceArchive: %v", err)
|
||||
}
|
||||
|
||||
got := readArchive(t, zstdBytes)
|
||||
contents, ok := got["plugin.mod"]
|
||||
if !ok {
|
||||
t.Fatalf("expected plugin.mod in archive, got %v", keys(got))
|
||||
}
|
||||
if !strings.Contains(contents, `version="0.1.1"`) {
|
||||
t.Errorf("archived plugin.mod should have dirty version 0.1.1, got: %q", contents)
|
||||
}
|
||||
if strings.Contains(contents, `version="0.1.0"`) {
|
||||
t.Errorf("archived plugin.mod should NOT have HEAD version 0.1.0, got: %q", contents)
|
||||
}
|
||||
|
||||
// Working tree should be unchanged after stash-create.
|
||||
postContents, err := os.ReadFile(modPath)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if string(postContents) != string(dirtyContents) {
|
||||
t.Errorf("working tree mutated after BuildSourceArchive\nwant: %q\ngot: %q",
|
||||
string(dirtyContents), string(postContents))
|
||||
}
|
||||
}
|
||||
|
||||
func TestBuildSourceArchive_DirtyTreeOmitsUntracked(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
runGitArchive(t, dir, "init", "-q")
|
||||
modPath := filepath.Join(dir, "plugin.mod")
|
||||
if err := os.WriteFile(modPath,
|
||||
[]byte("[plugin]\nname=\"x\"\nscope=\"@s\"\nversion=\"0.1.0\"\n"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
runGitArchive(t, dir, "add", "plugin.mod")
|
||||
runGitArchive(t, dir, "commit", "-qm", "init")
|
||||
|
||||
// Dirty the tracked file.
|
||||
if err := os.WriteFile(modPath,
|
||||
[]byte("[plugin]\nname=\"x\"\nscope=\"@s\"\nversion=\"0.1.1\"\n"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
// Add an untracked file (no git add).
|
||||
if err := os.WriteFile(filepath.Join(dir, "extra.txt"), []byte("not tracked"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
zstdBytes, err := BuildSourceArchive(dir)
|
||||
if err != nil {
|
||||
t.Fatalf("BuildSourceArchive: %v", err)
|
||||
}
|
||||
|
||||
got := readArchive(t, zstdBytes)
|
||||
if _, ok := got["extra.txt"]; ok {
|
||||
t.Errorf("untracked extra.txt should not be in archive, got %v", keys(got))
|
||||
}
|
||||
}
|
||||
|
||||
func runGitArchive(t *testing.T, dir string, args ...string) {
|
||||
t.Helper()
|
||||
cmd := exec.Command("git", args...)
|
||||
cmd.Dir = dir
|
||||
cmd.Env = append(os.Environ(),
|
||||
"GIT_AUTHOR_NAME=t",
|
||||
"GIT_AUTHOR_EMAIL=t@t",
|
||||
"GIT_COMMITTER_NAME=t",
|
||||
"GIT_COMMITTER_EMAIL=t@t",
|
||||
)
|
||||
out, err := cmd.CombinedOutput()
|
||||
if err != nil {
|
||||
t.Fatalf("git %v: %v\n%s", args, err, out)
|
||||
}
|
||||
}
|
||||
|
||||
func readArchive(t *testing.T, zstdBytes []byte) map[string]string {
|
||||
t.Helper()
|
||||
dec, err := zstd.NewReader(bytes.NewReader(zstdBytes))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer dec.Close()
|
||||
tr := tar.NewReader(dec)
|
||||
got := map[string]string{}
|
||||
for {
|
||||
hdr, err := tr.Next()
|
||||
if err == io.EOF {
|
||||
break
|
||||
}
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
buf, err := io.ReadAll(tr)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
got[hdr.Name] = string(buf)
|
||||
}
|
||||
return got
|
||||
}
|
||||
279
internal/bnp/build.go
Normal file
279
internal/bnp/build.go
Normal file
@ -0,0 +1,279 @@
|
||||
package bnp
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"fmt"
|
||||
"os"
|
||||
"os/exec"
|
||||
"path/filepath"
|
||||
"regexp"
|
||||
"sort"
|
||||
"strconv"
|
||||
|
||||
abiv1 "git.dev.alexdunmow.com/block/core/abi/v1"
|
||||
core "git.dev.alexdunmow.com/block/core/plugin"
|
||||
"google.golang.org/protobuf/proto"
|
||||
)
|
||||
|
||||
// Required top-level artifact members (mirrors the CMS reader).
|
||||
const (
|
||||
fileWasm = "plugin.wasm"
|
||||
fileMod = "plugin.mod"
|
||||
fileManifest = "manifest.pb"
|
||||
)
|
||||
|
||||
// minGoMajor/minGoMinor is the lowest Go toolchain that can emit reactor-mode
|
||||
// (`-buildmode=c-shared`) wasip1 modules the guest shim relies on.
|
||||
const (
|
||||
minGoMajor = 1
|
||||
minGoMinor = 24
|
||||
)
|
||||
|
||||
// BuildOptions configures Build.
|
||||
type BuildOptions struct {
|
||||
// Dir is the plugin repo root (holds plugin.mod and the main Go package).
|
||||
Dir string
|
||||
// Output is the destination .bnp path. Empty → "<name>-<version>.bnp" in
|
||||
// the current working directory.
|
||||
Output string
|
||||
}
|
||||
|
||||
// BuildResult summarizes a produced artifact for the CLI summary table.
|
||||
type BuildResult struct {
|
||||
OutputPath string
|
||||
Name string
|
||||
Version string
|
||||
// Codeless marks a declarative artifact (no plugin.wasm, WO-WZ-020).
|
||||
Codeless bool
|
||||
WasmBytes int64
|
||||
ManifestBytes int64
|
||||
ArtifactBytes int64 // on-disk .bnp size
|
||||
UncompBytes int64 // sum of packed file sizes
|
||||
BlockCount int
|
||||
TemplateCount int
|
||||
AdminPages int
|
||||
JobTypes int
|
||||
Hooks []string
|
||||
DataDir bool
|
||||
IncludedDirs []string
|
||||
}
|
||||
|
||||
// Build compiles the plugin in opts.Dir to wasm, extracts its manifest, and
|
||||
// packs a .bnp. No Docker/podman: the whole pipeline is the local Go
|
||||
// toolchain + wazero + tar.zst.
|
||||
func Build(ctx context.Context, opts BuildOptions) (*BuildResult, error) {
|
||||
dir := opts.Dir
|
||||
if dir == "" {
|
||||
dir = "."
|
||||
}
|
||||
dir, err := filepath.Abs(dir)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("resolve dir: %w", err)
|
||||
}
|
||||
|
||||
modPath := filepath.Join(dir, fileMod)
|
||||
modBytes, err := os.ReadFile(modPath)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("read plugin.mod (is %s a plugin repo?): %w", dir, err)
|
||||
}
|
||||
mod, err := core.ParseModFull(modBytes)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("parse plugin.mod: %w", err)
|
||||
}
|
||||
if mod.Plugin.Name == "" || mod.Plugin.Version == "" {
|
||||
return nil, fmt.Errorf("plugin.mod must set both name and version")
|
||||
}
|
||||
|
||||
if err := checkGoVersion(ctx); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// 1. Compile to reactor-mode wasip1 c-shared.
|
||||
tmp, err := os.MkdirTemp("", "ninja-build-*")
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("temp dir: %w", err)
|
||||
}
|
||||
defer func() { _ = os.RemoveAll(tmp) }()
|
||||
wasmPath := filepath.Join(tmp, fileWasm)
|
||||
if err := buildWasm(ctx, dir, wasmPath); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// 2. Extract the manifest by driving DESCRIBE.
|
||||
wasm, err := readWasm(wasmPath)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
manifest, err := ExtractManifest(ctx, wasm)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("extract manifest: %w", err)
|
||||
}
|
||||
|
||||
// 3. Validate against plugin.mod before packing an incoherent artifact.
|
||||
if manifest.GetName() != mod.Plugin.Name {
|
||||
return nil, fmt.Errorf("manifest name %q != plugin.mod name %q", manifest.GetName(), mod.Plugin.Name)
|
||||
}
|
||||
if v := manifest.GetAbiVersion(); v != hostAbiVersion {
|
||||
return nil, fmt.Errorf("manifest abi_version %d unsupported (packer speaks %d)", v, hostAbiVersion)
|
||||
}
|
||||
|
||||
// 4. Stamp the data_dir grant from plugin.mod. DESCRIBE cannot see
|
||||
// plugin.mod (it lives outside guest code), so the packer is where the
|
||||
// grant crosses from mod → manifest; the loader then reads one source.
|
||||
manifest.DataDir = mod.Plugin.DataDir
|
||||
|
||||
// 4b. Mixed-form artifacts (WO-WZ-021): a reduced wasm plugin may keep a
|
||||
// minimal guest for genuine logic (a contact route, Stripe) while its
|
||||
// declarative surfaces (theme presets, bundled fonts, master pages,
|
||||
// system/page templates, template overrides, email wrappers, css,
|
||||
// required icon packs) live in an optional root manifest.yaml — exactly
|
||||
// the codeless declarative set. Fold it into the DESCRIBE-derived
|
||||
// manifest just as BuildCodeless does: the declarative keys
|
||||
// supplement/override the guest's, and the referenced root JSON
|
||||
// (presets.json / master_pages.json / fonts.json) is embedded into
|
||||
// manifest.pb (not packed separately, same as codeless). The templates/
|
||||
// dir carrying the .ninjatpl sources already rides the optional-dir
|
||||
// pack below. A repo with NO manifest.yaml is a no-op here
|
||||
// (applyManifestYAML returns nil on os.IsNotExist), so an existing
|
||||
// pure-wasm plugin builds byte-for-byte as before.
|
||||
if err := applyManifestYAML(dir, manifest); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
manifestBytes, err := proto.Marshal(manifest)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("marshal manifest.pb: %w", err)
|
||||
}
|
||||
|
||||
// 5. Assemble artifact entries.
|
||||
entries := []packEntry{
|
||||
{ArtifactPath: fileWasm, Source: wasmPath},
|
||||
{ArtifactPath: fileMod, Source: modPath},
|
||||
{ArtifactPath: fileManifest, Data: manifestBytes},
|
||||
}
|
||||
var includedDirs []string
|
||||
// dir-name → source subpath. web ships the Module Federation build output
|
||||
// (web/dist) flattened under web/ so the reader's dirExists("web") fires.
|
||||
optional := []struct{ artifact, src string }{
|
||||
{dirBlocks, dirBlocks},
|
||||
{dirTemplates, dirTemplates},
|
||||
{dirSeed, dirSeed},
|
||||
{"migrations", "migrations"},
|
||||
{"schemas", "schemas"},
|
||||
{"assets", "assets"},
|
||||
{"web", filepath.Join("web", "dist")},
|
||||
}
|
||||
// Declarative dirs ride along on wasm artifacts too (a reduced plugin may
|
||||
// mix definition-backed blocks with logic); validate them identically.
|
||||
if _, err := validateBlocksDir(dir); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := validateSeedDir(dir); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for _, o := range optional {
|
||||
dirEntries, has, dErr := collectDir(filepath.Join(dir, o.src), o.artifact)
|
||||
if dErr != nil {
|
||||
return nil, dErr
|
||||
}
|
||||
if has {
|
||||
entries = append(entries, dirEntries...)
|
||||
includedDirs = append(includedDirs, o.artifact)
|
||||
}
|
||||
}
|
||||
|
||||
// 6. Pack.
|
||||
outPath := opts.Output
|
||||
if outPath == "" {
|
||||
outPath = fmt.Sprintf("%s-%s.bnp", mod.Plugin.Name, mod.Plugin.Version)
|
||||
}
|
||||
uncomp, err := packArtifact(outPath, entries)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
artInfo, err := os.Stat(outPath)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("stat artifact: %w", err)
|
||||
}
|
||||
wasmInfo, _ := os.Stat(wasmPath)
|
||||
|
||||
return &BuildResult{
|
||||
OutputPath: outPath,
|
||||
Name: manifest.GetName(),
|
||||
Version: manifest.GetVersion(),
|
||||
WasmBytes: wasmInfo.Size(),
|
||||
ManifestBytes: int64(len(manifestBytes)),
|
||||
ArtifactBytes: artInfo.Size(),
|
||||
UncompBytes: uncomp,
|
||||
BlockCount: len(manifest.GetBlocks()),
|
||||
TemplateCount: len(manifest.GetTemplateKeys()),
|
||||
AdminPages: len(manifest.GetAdminPages()),
|
||||
JobTypes: len(manifest.GetJobTypes()),
|
||||
Hooks: hooksPresent(manifest),
|
||||
DataDir: manifest.GetDataDir(),
|
||||
IncludedDirs: includedDirs,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// buildWasm runs the reactor-mode wasip1 c-shared build in dir.
|
||||
func buildWasm(ctx context.Context, dir, outPath string) error {
|
||||
cmd := exec.CommandContext(ctx, "go", "build", "-buildmode=c-shared", "-o", outPath, ".")
|
||||
cmd.Dir = dir
|
||||
cmd.Env = append(os.Environ(), "GOOS=wasip1", "GOARCH=wasm")
|
||||
var stderr bytes.Buffer
|
||||
cmd.Stderr = &stderr
|
||||
if err := cmd.Run(); err != nil {
|
||||
return fmt.Errorf("go build (GOOS=wasip1 GOARCH=wasm -buildmode=c-shared) failed: %w\n%s", err, stderr.String())
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
var goVersionRe = regexp.MustCompile(`go(\d+)\.(\d+)(?:\.\d+)?`)
|
||||
|
||||
// checkGoVersion enforces the minimum toolchain (Go 1.24) with a clear error.
|
||||
func checkGoVersion(ctx context.Context) error {
|
||||
out, err := exec.CommandContext(ctx, "go", "version").Output()
|
||||
if err != nil {
|
||||
return fmt.Errorf("`go version` failed (is the Go toolchain on PATH?): %w", err)
|
||||
}
|
||||
m := goVersionRe.FindStringSubmatch(string(out))
|
||||
if m == nil {
|
||||
return fmt.Errorf("could not parse Go version from %q", string(out))
|
||||
}
|
||||
major, _ := strconv.Atoi(m[1])
|
||||
minor, _ := strconv.Atoi(m[2])
|
||||
if major < minGoMajor || (major == minGoMajor && minor < minGoMinor) {
|
||||
return fmt.Errorf(
|
||||
"building reactor-mode wasip1 plugins requires Go %d.%d+; found %d.%d — upgrade your toolchain",
|
||||
minGoMajor, minGoMinor, major, minor)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// hooksPresent returns the sorted set of runtime hooks the manifest declares,
|
||||
// for the summary table.
|
||||
func hooksPresent(m *abiv1.PluginManifest) []string {
|
||||
var hooks []string
|
||||
if m.GetHasLoadHook() {
|
||||
hooks = append(hooks, "load")
|
||||
}
|
||||
if m.GetHasUnloadHook() {
|
||||
hooks = append(hooks, "unload")
|
||||
}
|
||||
if m.GetHasHttpHandler() {
|
||||
hooks = append(hooks, "http")
|
||||
}
|
||||
if m.GetHasMediaHooks() {
|
||||
hooks = append(hooks, "media")
|
||||
}
|
||||
if len(m.GetJobTypes()) > 0 {
|
||||
hooks = append(hooks, "job")
|
||||
}
|
||||
if len(m.GetRagContentFetcherTypes()) > 0 {
|
||||
hooks = append(hooks, "rag")
|
||||
}
|
||||
sort.Strings(hooks)
|
||||
return hooks
|
||||
}
|
||||
515
internal/bnp/codeless.go
Normal file
515
internal/bnp/codeless.go
Normal file
@ -0,0 +1,515 @@
|
||||
package bnp
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
|
||||
abiv1 "git.dev.alexdunmow.com/block/core/abi/v1"
|
||||
core "git.dev.alexdunmow.com/block/core/plugin"
|
||||
"google.golang.org/protobuf/proto"
|
||||
"gopkg.in/yaml.v3"
|
||||
)
|
||||
|
||||
// Codeless artifacts (WO-WZ-020): a .bnp with NO plugin.wasm — pure
|
||||
// declaration the host runs. Classification is by repo shape: a plugin repo
|
||||
// with no Go source builds codeless; a repo with Go builds wasm as always
|
||||
// (a converted repo DELETES its Go — that's the point). Both artifact kinds
|
||||
// may carry blocks/, templates/, and seed/; codeless just has nothing else.
|
||||
|
||||
// Declarative artifact dirs shared by both build paths.
|
||||
const (
|
||||
dirBlocks = "blocks"
|
||||
dirTemplates = "templates"
|
||||
dirSeed = "seed"
|
||||
)
|
||||
|
||||
// manifestYAMLName is the optional root-level declarative manifest source for
|
||||
// codeless plugins (the counterpart of what DESCRIBE captures from Go code).
|
||||
const manifestYAMLName = "manifest.yaml"
|
||||
|
||||
// manifestYAML mirrors the declarative PluginManifest fields a codeless
|
||||
// plugin can set. File-valued keys are paths relative to the repo root.
|
||||
type manifestYAML struct {
|
||||
ThemePresets string `yaml:"theme_presets"` // JSON file
|
||||
BundledFonts string `yaml:"bundled_fonts"` // JSON file
|
||||
SettingsSchema string `yaml:"settings_schema"` // JSON file
|
||||
MasterPages string `yaml:"master_pages"` // JSON file ([]masterPageJSON)
|
||||
RequiredIconPacks []string `yaml:"required_icon_packs"`
|
||||
SystemTemplates []struct {
|
||||
Key string `yaml:"key"`
|
||||
Title string `yaml:"title"`
|
||||
Description string `yaml:"description"`
|
||||
} `yaml:"system_templates"`
|
||||
PageTemplates []struct {
|
||||
System string `yaml:"system"`
|
||||
Key string `yaml:"key"`
|
||||
Title string `yaml:"title"`
|
||||
Description string `yaml:"description"`
|
||||
Slots []string `yaml:"slots"`
|
||||
} `yaml:"page_templates"`
|
||||
// TemplateOverrides declare theme-scoped overrides of builtin block
|
||||
// rendering. Source convention: templates/overrides/<template>/<block>.ninjatpl,
|
||||
// rendered host-side with the block's content map as the template context.
|
||||
TemplateOverrides []struct {
|
||||
Template string `yaml:"template"` // template/system key the override binds to
|
||||
Block string `yaml:"block"` // builtin block key being overridden
|
||||
} `yaml:"template_overrides"`
|
||||
// EmailWrappers declare branded email wrappers per system key. Source
|
||||
// convention: templates/email/<system>.ninjatpl, rendered host-side with
|
||||
// body/colors/site/unsubscribe_url/preview_text in the context (emit the
|
||||
// pre-rendered body with |safe).
|
||||
EmailWrappers []string `yaml:"email_wrappers"`
|
||||
CSS *struct {
|
||||
NpmPackages map[string]string `yaml:"npm_packages"`
|
||||
CSSDirectives []string `yaml:"css_directives"`
|
||||
InputCSSAppend string `yaml:"input_css_append"`
|
||||
} `yaml:"css"`
|
||||
Dependencies []struct {
|
||||
Plugin string `yaml:"plugin"`
|
||||
MinVersion string `yaml:"min_version"`
|
||||
Required bool `yaml:"required"`
|
||||
} `yaml:"dependencies"`
|
||||
}
|
||||
|
||||
// masterPageJSON mirrors abiv1.MasterPageDefinition for the declarative file.
|
||||
type masterPageJSON struct {
|
||||
Key string `json:"key"`
|
||||
Title string `json:"title"`
|
||||
PageTemplates []string `json:"page_templates"`
|
||||
Blocks []struct {
|
||||
BlockKey string `json:"block_key"`
|
||||
Title string `json:"title"`
|
||||
Content map[string]any `json:"content"`
|
||||
HTMLContent *string `json:"html_content"`
|
||||
Slot string `json:"slot"`
|
||||
SortOrder int32 `json:"sort_order"`
|
||||
} `json:"blocks"`
|
||||
}
|
||||
|
||||
// blocksYAML is the structural mirror of the CMS blocks.yaml manifest
|
||||
// (cms blocks.LoadManifest) — a deliberate light duplication, same as the
|
||||
// Verify↔reader pairing: the packer validates shape and file presence; full
|
||||
// semantic validation (schema/template/provider checks) runs at install.
|
||||
type blocksYAML struct {
|
||||
Blocks []struct {
|
||||
Key string `yaml:"key"`
|
||||
Title string `yaml:"title"`
|
||||
Description string `yaml:"description"`
|
||||
Category string `yaml:"category"`
|
||||
Schema string `yaml:"schema"`
|
||||
Template string `yaml:"template"`
|
||||
SampleData string `yaml:"sample_data"`
|
||||
Providers []string `yaml:"providers"`
|
||||
RequiredTags []string `yaml:"required_tags"`
|
||||
Aliases []string `yaml:"aliases"`
|
||||
} `yaml:"blocks"`
|
||||
}
|
||||
|
||||
// seedJSON is the declarative seed schema (seed/seed.json). Applied by the
|
||||
// host at load via the WO-WZ-019 provisioner (idempotent).
|
||||
type seedJSON struct {
|
||||
Settings *struct {
|
||||
Merge map[string]any `json:"merge"`
|
||||
Override map[string]any `json:"override"`
|
||||
Ensure map[string]any `json:"ensure"`
|
||||
} `json:"settings"`
|
||||
Media []struct {
|
||||
ID string `json:"id"` // UUID, required (deterministic media key)
|
||||
File string `json:"file"`
|
||||
Alt string `json:"alt"`
|
||||
Folder string `json:"folder"`
|
||||
} `json:"media"`
|
||||
Pages []struct {
|
||||
Slug string `json:"slug"`
|
||||
ParentSlug string `json:"parent_slug"`
|
||||
Title string `json:"title"`
|
||||
TemplateKey string `json:"template_key"`
|
||||
ReconcileBlocks bool `json:"reconcile_blocks"`
|
||||
ReconcileTemplate bool `json:"reconcile_template"`
|
||||
Blocks []struct {
|
||||
BlockKey string `json:"block_key"`
|
||||
Title string `json:"title"`
|
||||
Content map[string]any `json:"content"`
|
||||
HTMLContent *string `json:"html_content"`
|
||||
Slot string `json:"slot"`
|
||||
SortOrder int32 `json:"sort_order"`
|
||||
} `json:"blocks"`
|
||||
} `json:"pages"`
|
||||
MenuItems []struct {
|
||||
Menu string `json:"menu"`
|
||||
Label string `json:"label"`
|
||||
URL string `json:"url"`
|
||||
PageSlug string `json:"page_slug"`
|
||||
SortOrder int32 `json:"sort_order"`
|
||||
} `json:"menu_items"`
|
||||
}
|
||||
|
||||
// IsCodelessRepo reports whether dir is a declarative plugin repo: it has a
|
||||
// plugin.mod but no Go source at the root (the wasm main package's home).
|
||||
func IsCodelessRepo(dir string) (bool, error) {
|
||||
if _, err := os.Stat(filepath.Join(dir, fileMod)); err != nil {
|
||||
return false, fmt.Errorf("read plugin.mod (is %s a plugin repo?): %w", dir, err)
|
||||
}
|
||||
entries, err := os.ReadDir(dir)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
for _, e := range entries {
|
||||
if !e.IsDir() && strings.HasSuffix(e.Name(), ".go") {
|
||||
return false, nil
|
||||
}
|
||||
}
|
||||
return true, nil
|
||||
}
|
||||
|
||||
// BuildCodeless synthesizes manifest.pb from plugin.mod + the declarative
|
||||
// files and packs a codeless .bnp (no plugin.wasm, no DESCRIBE probe).
|
||||
func BuildCodeless(_ context.Context, opts BuildOptions) (*BuildResult, error) {
|
||||
dir := opts.Dir
|
||||
if dir == "" {
|
||||
dir = "."
|
||||
}
|
||||
dir, err := filepath.Abs(dir)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("resolve dir: %w", err)
|
||||
}
|
||||
|
||||
modPath := filepath.Join(dir, fileMod)
|
||||
modBytes, err := os.ReadFile(modPath)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("read plugin.mod: %w", err)
|
||||
}
|
||||
mod, err := core.ParseModFull(modBytes)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("parse plugin.mod: %w", err)
|
||||
}
|
||||
if mod.Plugin.Name == "" || mod.Plugin.Version == "" {
|
||||
return nil, fmt.Errorf("plugin.mod must set both name and version")
|
||||
}
|
||||
if mod.Plugin.DataDir {
|
||||
return nil, fmt.Errorf("codeless plugin cannot request data_dir — there is no code to use it")
|
||||
}
|
||||
|
||||
manifest := &abiv1.PluginManifest{
|
||||
AbiVersion: hostAbiVersion,
|
||||
Name: mod.Plugin.Name,
|
||||
Version: mod.Plugin.Version,
|
||||
Codeless: true,
|
||||
}
|
||||
|
||||
blockCount, err := validateBlocksDir(dir)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := validateSeedDir(dir); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := applyManifestYAML(dir, manifest); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
manifestBytes, err := proto.Marshal(manifest)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("marshal manifest.pb: %w", err)
|
||||
}
|
||||
|
||||
entries := []packEntry{
|
||||
{ArtifactPath: fileMod, Source: modPath},
|
||||
{ArtifactPath: fileManifest, Data: manifestBytes},
|
||||
}
|
||||
var includedDirs []string
|
||||
optional := []struct{ artifact, src string }{
|
||||
{dirBlocks, dirBlocks},
|
||||
{dirTemplates, dirTemplates},
|
||||
{dirSeed, dirSeed},
|
||||
{"migrations", "migrations"},
|
||||
{"schemas", "schemas"},
|
||||
{"assets", "assets"},
|
||||
}
|
||||
for _, o := range optional {
|
||||
dirEntries, has, dErr := collectDir(filepath.Join(dir, o.src), o.artifact)
|
||||
if dErr != nil {
|
||||
return nil, dErr
|
||||
}
|
||||
if has {
|
||||
entries = append(entries, dirEntries...)
|
||||
includedDirs = append(includedDirs, o.artifact)
|
||||
}
|
||||
}
|
||||
|
||||
outPath := opts.Output
|
||||
if outPath == "" {
|
||||
outPath = fmt.Sprintf("%s-%s.bnp", mod.Plugin.Name, mod.Plugin.Version)
|
||||
}
|
||||
uncomp, err := packArtifact(outPath, entries)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
artInfo, err := os.Stat(outPath)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("stat artifact: %w", err)
|
||||
}
|
||||
|
||||
return &BuildResult{
|
||||
OutputPath: outPath,
|
||||
Name: manifest.GetName(),
|
||||
Version: manifest.GetVersion(),
|
||||
Codeless: true,
|
||||
ManifestBytes: int64(len(manifestBytes)),
|
||||
ArtifactBytes: artInfo.Size(),
|
||||
UncompBytes: uncomp,
|
||||
BlockCount: blockCount,
|
||||
IncludedDirs: includedDirs,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// validateBlocksDir structurally validates blocks/blocks.yaml when present:
|
||||
// every entry has key/title/schema/template, referenced files exist within
|
||||
// blocks/, and schemas are valid JSON. Returns the block count (0 when the
|
||||
// dir is absent).
|
||||
func validateBlocksDir(dir string) (int, error) {
|
||||
root := filepath.Join(dir, dirBlocks)
|
||||
manifestPath := filepath.Join(root, "blocks.yaml")
|
||||
if _, err := os.Stat(root); os.IsNotExist(err) {
|
||||
return 0, nil
|
||||
}
|
||||
raw, err := os.ReadFile(manifestPath)
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("blocks/ present but blocks.yaml unreadable: %w", err)
|
||||
}
|
||||
var bf blocksYAML
|
||||
if err := yaml.Unmarshal(raw, &bf); err != nil {
|
||||
return 0, fmt.Errorf("parse blocks/blocks.yaml: %w", err)
|
||||
}
|
||||
seen := map[string]bool{}
|
||||
for i, b := range bf.Blocks {
|
||||
if b.Key == "" {
|
||||
return 0, fmt.Errorf("blocks.yaml: entry %d has no key", i)
|
||||
}
|
||||
if seen[b.Key] {
|
||||
return 0, fmt.Errorf("blocks.yaml: duplicate key %q", b.Key)
|
||||
}
|
||||
seen[b.Key] = true
|
||||
if b.Title == "" || b.Schema == "" || b.Template == "" {
|
||||
return 0, fmt.Errorf("blocks.yaml: %q must declare title, schema, and template", b.Key)
|
||||
}
|
||||
for _, f := range []string{b.Schema, b.Template, b.SampleData} {
|
||||
if f == "" {
|
||||
continue
|
||||
}
|
||||
if err := fileWithin(root, f); err != nil {
|
||||
return 0, fmt.Errorf("blocks.yaml: %q: %w", b.Key, err)
|
||||
}
|
||||
}
|
||||
schemaRaw, err := os.ReadFile(filepath.Join(root, b.Schema))
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("blocks.yaml: %q schema: %w", b.Key, err)
|
||||
}
|
||||
if !json.Valid(schemaRaw) {
|
||||
return 0, fmt.Errorf("blocks.yaml: %q schema %s is not valid JSON", b.Key, b.Schema)
|
||||
}
|
||||
}
|
||||
return len(bf.Blocks), nil
|
||||
}
|
||||
|
||||
// validateSeedDir validates seed/seed.json when the dir is present: it
|
||||
// parses, media entries carry an id + an existing file, pages carry slugs.
|
||||
func validateSeedDir(dir string) error {
|
||||
root := filepath.Join(dir, dirSeed)
|
||||
if _, err := os.Stat(root); os.IsNotExist(err) {
|
||||
return nil
|
||||
}
|
||||
raw, err := os.ReadFile(filepath.Join(root, "seed.json"))
|
||||
if err != nil {
|
||||
return fmt.Errorf("seed/ present but seed.json unreadable: %w", err)
|
||||
}
|
||||
var sf seedJSON
|
||||
if err := json.Unmarshal(raw, &sf); err != nil {
|
||||
return fmt.Errorf("parse seed/seed.json: %w", err)
|
||||
}
|
||||
for i, m := range sf.Media {
|
||||
if m.ID == "" || m.File == "" {
|
||||
return fmt.Errorf("seed.json: media entry %d needs both id and file", i)
|
||||
}
|
||||
if err := fileWithin(root, m.File); err != nil {
|
||||
return fmt.Errorf("seed.json: media %q: %w", m.ID, err)
|
||||
}
|
||||
}
|
||||
for i, p := range sf.Pages {
|
||||
if p.Slug == "" || p.Title == "" {
|
||||
return fmt.Errorf("seed.json: page entry %d needs slug and title", i)
|
||||
}
|
||||
}
|
||||
for i, mi := range sf.MenuItems {
|
||||
if mi.Menu == "" || mi.Label == "" {
|
||||
return fmt.Errorf("seed.json: menu item %d needs menu and label", i)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// applyManifestYAML folds the optional root manifest.yaml into the manifest.
|
||||
func applyManifestYAML(dir string, m *abiv1.PluginManifest) error {
|
||||
raw, err := os.ReadFile(filepath.Join(dir, manifestYAMLName))
|
||||
if os.IsNotExist(err) {
|
||||
return nil
|
||||
}
|
||||
if err != nil {
|
||||
return fmt.Errorf("read %s: %w", manifestYAMLName, err)
|
||||
}
|
||||
var my manifestYAML
|
||||
if err := yaml.Unmarshal(raw, &my); err != nil {
|
||||
return fmt.Errorf("parse %s: %w", manifestYAMLName, err)
|
||||
}
|
||||
|
||||
readJSONFile := func(rel, what string) ([]byte, error) {
|
||||
if rel == "" {
|
||||
return nil, nil
|
||||
}
|
||||
if err := fileWithin(dir, rel); err != nil {
|
||||
return nil, fmt.Errorf("%s: %s: %w", manifestYAMLName, what, err)
|
||||
}
|
||||
b, err := os.ReadFile(filepath.Join(dir, rel))
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("%s: %s: %w", manifestYAMLName, what, err)
|
||||
}
|
||||
if !json.Valid(b) {
|
||||
return nil, fmt.Errorf("%s: %s %s is not valid JSON", manifestYAMLName, what, rel)
|
||||
}
|
||||
return b, nil
|
||||
}
|
||||
|
||||
// Only overwrite a field when manifest.yaml actually declares it. For a
|
||||
// codeless build the manifest starts empty, so an undeclared key leaving the
|
||||
// field at its proto zero is identical to the old unconditional assignment.
|
||||
// For a mixed-form wasm build the manifest already carries the guest's
|
||||
// DESCRIBE output, so these guards are what keep an undeclared key from
|
||||
// WIPING a guest-populated field (theme_presets/bundled_fonts/etc.) —
|
||||
// declarative keys supplement/override, they never clear (WO-WZ-021).
|
||||
if my.ThemePresets != "" {
|
||||
if m.ThemePresets, err = readJSONFile(my.ThemePresets, "theme_presets"); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
if my.BundledFonts != "" {
|
||||
if m.BundledFonts, err = readJSONFile(my.BundledFonts, "bundled_fonts"); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
if my.SettingsSchema != "" {
|
||||
if m.SettingsSchema, err = readJSONFile(my.SettingsSchema, "settings_schema"); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
if len(my.RequiredIconPacks) > 0 {
|
||||
m.RequiredIconPacks = my.RequiredIconPacks
|
||||
}
|
||||
if my.CSS != nil {
|
||||
m.CssManifest = &abiv1.CssManifest{
|
||||
NpmPackages: my.CSS.NpmPackages,
|
||||
CssDirectives: my.CSS.CSSDirectives,
|
||||
InputCssAppend: my.CSS.InputCSSAppend,
|
||||
}
|
||||
}
|
||||
for _, d := range my.Dependencies {
|
||||
m.Dependencies = append(m.Dependencies, &abiv1.Dependency{
|
||||
Plugin: d.Plugin, MinVersion: d.MinVersion, Required: d.Required,
|
||||
})
|
||||
}
|
||||
|
||||
for _, st := range my.SystemTemplates {
|
||||
if st.Key == "" || st.Title == "" {
|
||||
return fmt.Errorf("%s: system_templates entries need key and title", manifestYAMLName)
|
||||
}
|
||||
m.SystemTemplates = append(m.SystemTemplates, &abiv1.SystemTemplateMeta{
|
||||
Key: st.Key, Title: st.Title, Description: st.Description,
|
||||
})
|
||||
}
|
||||
for _, pt := range my.PageTemplates {
|
||||
if pt.System == "" || pt.Key == "" || pt.Title == "" {
|
||||
return fmt.Errorf("%s: page_templates entries need system, key, and title", manifestYAMLName)
|
||||
}
|
||||
// Layout source convention: templates/<system>/<key>.ninjatpl,
|
||||
// rendered host-side (core/docs/codeless-bnp.md).
|
||||
rel := filepath.Join(dirTemplates, pt.System, pt.Key+".ninjatpl")
|
||||
if err := fileWithin(dir, rel); err != nil {
|
||||
return fmt.Errorf("%s: page template %s/%s: %w", manifestYAMLName, pt.System, pt.Key, err)
|
||||
}
|
||||
m.PageTemplates = append(m.PageTemplates, &abiv1.PageTemplateMeta{
|
||||
SystemKey: pt.System, Key: pt.Key, Title: pt.Title,
|
||||
Description: pt.Description, Slots: pt.Slots,
|
||||
})
|
||||
}
|
||||
|
||||
for _, to := range my.TemplateOverrides {
|
||||
if to.Template == "" || to.Block == "" {
|
||||
return fmt.Errorf("%s: template_overrides entries need template and block", manifestYAMLName)
|
||||
}
|
||||
rel := filepath.Join(dirTemplates, "overrides", to.Template, to.Block+".ninjatpl")
|
||||
if err := fileWithin(dir, rel); err != nil {
|
||||
return fmt.Errorf("%s: template override %s/%s: %w", manifestYAMLName, to.Template, to.Block, err)
|
||||
}
|
||||
m.BlockTemplateOverrides = append(m.BlockTemplateOverrides, &abiv1.BlockTemplateOverride{
|
||||
TemplateKey: to.Template, BlockKey: to.Block,
|
||||
})
|
||||
}
|
||||
for _, ek := range my.EmailWrappers {
|
||||
if ek == "" {
|
||||
return fmt.Errorf("%s: email_wrappers entries must be non-empty system keys", manifestYAMLName)
|
||||
}
|
||||
rel := filepath.Join(dirTemplates, "email", ek+".ninjatpl")
|
||||
if err := fileWithin(dir, rel); err != nil {
|
||||
return fmt.Errorf("%s: email wrapper %s: %w", manifestYAMLName, ek, err)
|
||||
}
|
||||
m.EmailWrapperSystemKeys = append(m.EmailWrapperSystemKeys, ek)
|
||||
}
|
||||
|
||||
if my.MasterPages != "" {
|
||||
mpRaw, err := readJSONFile(my.MasterPages, "master_pages")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
var mps []masterPageJSON
|
||||
if err := json.Unmarshal(mpRaw, &mps); err != nil {
|
||||
return fmt.Errorf("%s: master_pages %s: %w", manifestYAMLName, my.MasterPages, err)
|
||||
}
|
||||
for _, mp := range mps {
|
||||
def := &abiv1.MasterPageDefinition{
|
||||
Key: mp.Key, Title: mp.Title, PageTemplates: mp.PageTemplates,
|
||||
}
|
||||
for _, b := range mp.Blocks {
|
||||
contentJSON, err := json.Marshal(b.Content)
|
||||
if err != nil {
|
||||
return fmt.Errorf("master page %q block %q: %w", mp.Key, b.BlockKey, err)
|
||||
}
|
||||
def.Blocks = append(def.Blocks, &abiv1.MasterPageBlock{
|
||||
BlockKey: b.BlockKey, Title: b.Title, ContentJson: contentJSON,
|
||||
HtmlContent: b.HTMLContent, Slot: b.Slot, SortOrder: b.SortOrder,
|
||||
})
|
||||
}
|
||||
m.MasterPages = append(m.MasterPages, def)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// fileWithin ensures rel names an existing regular file inside root (no
|
||||
// traversal escapes).
|
||||
func fileWithin(root, rel string) error {
|
||||
clean := filepath.Clean(rel)
|
||||
if filepath.IsAbs(clean) || strings.HasPrefix(clean, "..") {
|
||||
return fmt.Errorf("path %q escapes the plugin directory", rel)
|
||||
}
|
||||
fi, err := os.Stat(filepath.Join(root, clean))
|
||||
if err != nil {
|
||||
return fmt.Errorf("referenced file %q: %w", rel, err)
|
||||
}
|
||||
if !fi.Mode().IsRegular() {
|
||||
return fmt.Errorf("referenced path %q is not a regular file", rel)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
183
internal/bnp/codeless_test.go
Normal file
183
internal/bnp/codeless_test.go
Normal file
@ -0,0 +1,183 @@
|
||||
package bnp
|
||||
|
||||
import (
|
||||
"context"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
|
||||
abiv1 "git.dev.alexdunmow.com/block/core/abi/v1"
|
||||
)
|
||||
|
||||
// writeFixture lays out a minimal codeless plugin repo.
|
||||
func writeFixture(t *testing.T, dir string, files map[string]string) {
|
||||
t.Helper()
|
||||
for rel, content := range files {
|
||||
path := filepath.Join(dir, rel)
|
||||
if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func codelessFixture(t *testing.T) string {
|
||||
t.Helper()
|
||||
dir := t.TempDir()
|
||||
writeFixture(t, dir, map[string]string{
|
||||
"plugin.mod": "[plugin]\nname = \"fixture-theme\"\nversion = \"0.1.0\"\nkind = \"theme\"\n",
|
||||
"manifest.yaml": "theme_presets: presets.json\nrequired_icon_packs: [lucide]\n" +
|
||||
"master_pages: master_pages.json\n" +
|
||||
"system_templates:\n - key: fixture\n title: Fixture Theme\n" +
|
||||
"page_templates:\n - system: fixture\n key: landing\n title: Landing\n slots: [main]\n" +
|
||||
"template_overrides:\n - template: fixture\n block: heading\n" +
|
||||
"email_wrappers: [fixture]\n",
|
||||
"templates/fixture/landing.ninjatpl": `<main>{{ content }}</main>`,
|
||||
"templates/overrides/fixture/heading.ninjatpl": `<h2 class="deco">{{ text }}</h2>`,
|
||||
"templates/email/fixture.ninjatpl": `<table><tr><td>{{ body|safe }}</td></tr></table>`,
|
||||
"presets.json": `{"presets":[{"key":"default"}]}`,
|
||||
"master_pages.json": `[{"key":"landing","title":"Landing","blocks":[{"block_key":"html","title":"Hero","content":{"x":1},"slot":"main","sort_order":1}]}]`,
|
||||
"blocks/blocks.yaml": "blocks:\n - key: hero\n title: Hero\n category: content\n" +
|
||||
" schema: hero.schema.json\n template: hero.ninjatpl\n providers: [site]\n",
|
||||
"blocks/hero.schema.json": `{"type":"object"}`,
|
||||
"blocks/hero.ninjatpl": `<h1>{{ title }}</h1>`,
|
||||
"seed/seed.json": `{"settings":{"ensure":{"welcome":true}},` +
|
||||
`"pages":[{"slug":"/","title":"Home","template_key":"landing"}],` +
|
||||
`"menu_items":[{"menu":"main","label":"Home","page_slug":"/","sort_order":1}]}`,
|
||||
"assets/logo.svg": `<svg/>`,
|
||||
})
|
||||
return dir
|
||||
}
|
||||
|
||||
func TestCodelessBuildAndVerifyRoundTrip(t *testing.T) {
|
||||
dir := codelessFixture(t)
|
||||
|
||||
isCodeless, err := IsCodelessRepo(dir)
|
||||
if err != nil || !isCodeless {
|
||||
t.Fatalf("IsCodelessRepo = %v, %v; want true", isCodeless, err)
|
||||
}
|
||||
|
||||
out := filepath.Join(t.TempDir(), "fixture-theme-0.1.0.bnp")
|
||||
res, err := BuildCodeless(context.Background(), BuildOptions{Dir: dir, Output: out})
|
||||
if err != nil {
|
||||
t.Fatalf("BuildCodeless: %v", err)
|
||||
}
|
||||
if !res.Codeless || res.BlockCount != 1 {
|
||||
t.Errorf("result = %+v; want codeless with 1 block", res)
|
||||
}
|
||||
|
||||
v, err := Verify(out)
|
||||
if err != nil {
|
||||
t.Fatalf("Verify: %v", err)
|
||||
}
|
||||
if !v.Codeless || !v.HasBlocks || !v.HasSeed || !v.HasAssets || v.Name != "fixture-theme" {
|
||||
t.Errorf("verify = %+v", v)
|
||||
}
|
||||
|
||||
m, err := ReadManifest(out)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(m.GetSystemTemplates()) != 1 || len(m.GetPageTemplates()) != 1 || m.GetPageTemplates()[0].GetSystemKey() != "fixture" {
|
||||
t.Errorf("templates = %v / %v", m.GetSystemTemplates(), m.GetPageTemplates())
|
||||
}
|
||||
if !m.GetCodeless() || len(m.GetMasterPages()) != 1 || len(m.GetThemePresets()) == 0 {
|
||||
t.Errorf("manifest = codeless:%v masters:%d presets:%dB",
|
||||
m.GetCodeless(), len(m.GetMasterPages()), len(m.GetThemePresets()))
|
||||
}
|
||||
if len(m.GetRequiredIconPacks()) != 1 || m.GetRequiredIconPacks()[0] != "lucide" {
|
||||
t.Errorf("icon packs = %v", m.GetRequiredIconPacks())
|
||||
}
|
||||
if len(m.GetBlockTemplateOverrides()) != 1 ||
|
||||
m.GetBlockTemplateOverrides()[0].GetTemplateKey() != "fixture" ||
|
||||
m.GetBlockTemplateOverrides()[0].GetBlockKey() != "heading" {
|
||||
t.Errorf("template overrides = %v", m.GetBlockTemplateOverrides())
|
||||
}
|
||||
if len(m.GetEmailWrapperSystemKeys()) != 1 || m.GetEmailWrapperSystemKeys()[0] != "fixture" {
|
||||
t.Errorf("email wrappers = %v", m.GetEmailWrapperSystemKeys())
|
||||
}
|
||||
}
|
||||
|
||||
func TestIsCodelessRepoFalseWithGoSource(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
writeFixture(t, dir, map[string]string{
|
||||
"plugin.mod": "[plugin]\nname = \"x\"\nversion = \"0.1.0\"\n",
|
||||
"main.go": "package main\nfunc main() {}\n",
|
||||
})
|
||||
isCodeless, err := IsCodelessRepo(dir)
|
||||
if err != nil || isCodeless {
|
||||
t.Fatalf("IsCodelessRepo = %v, %v; want false", isCodeless, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCodelessBuildRejectsBadDeclarations(t *testing.T) {
|
||||
cases := []struct {
|
||||
name string
|
||||
files map[string]string
|
||||
}{
|
||||
{"bad blocks yaml", map[string]string{
|
||||
"plugin.mod": "[plugin]\nname = \"x\"\nversion = \"0.1.0\"\n",
|
||||
"blocks/blocks.yaml": "blocks:\n - key: hero\n", // missing title/schema/template
|
||||
}},
|
||||
{"missing template file", map[string]string{
|
||||
"plugin.mod": "[plugin]\nname = \"x\"\nversion = \"0.1.0\"\n",
|
||||
"blocks/blocks.yaml": "blocks:\n - key: hero\n title: Hero\n" +
|
||||
" schema: hero.schema.json\n template: missing.ninjatpl\n",
|
||||
"blocks/hero.schema.json": `{}`,
|
||||
}},
|
||||
{"seed media without id", map[string]string{
|
||||
"plugin.mod": "[plugin]\nname = \"x\"\nversion = \"0.1.0\"\n",
|
||||
"seed/seed.json": `{"media":[{"file":"a.jpg"}]}`,
|
||||
"seed/a.jpg": "x",
|
||||
}},
|
||||
{"data_dir grant", map[string]string{
|
||||
"plugin.mod": "[plugin]\nname = \"x\"\nversion = \"0.1.0\"\ndata_dir = true\n",
|
||||
}},
|
||||
{"override missing template file", map[string]string{
|
||||
"plugin.mod": "[plugin]\nname = \"x\"\nversion = \"0.1.0\"\n",
|
||||
"manifest.yaml": "template_overrides:\n - template: x\n block: heading\n",
|
||||
}},
|
||||
{"override missing block key", map[string]string{
|
||||
"plugin.mod": "[plugin]\nname = \"x\"\nversion = \"0.1.0\"\n",
|
||||
"manifest.yaml": "template_overrides:\n - template: x\n",
|
||||
"templates/overrides/x/heading.ninjatpl": `<h1>{{ text }}</h1>`,
|
||||
}},
|
||||
{"email wrapper missing template file", map[string]string{
|
||||
"plugin.mod": "[plugin]\nname = \"x\"\nversion = \"0.1.0\"\n",
|
||||
"manifest.yaml": "email_wrappers: [x]\n",
|
||||
}},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
writeFixture(t, dir, tc.files)
|
||||
_, err := BuildCodeless(context.Background(), BuildOptions{
|
||||
Dir: dir, Output: filepath.Join(t.TempDir(), "x.bnp"),
|
||||
})
|
||||
if err == nil {
|
||||
t.Fatal("BuildCodeless succeeded; want error")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestCodelessHookViolation(t *testing.T) {
|
||||
ok := &abiv1.PluginManifest{Codeless: true, Name: "x"}
|
||||
if err := CodelessHookViolation(ok); err != nil {
|
||||
t.Fatalf("clean manifest flagged: %v", err)
|
||||
}
|
||||
bad := []*abiv1.PluginManifest{
|
||||
{Codeless: true, HasHttpHandler: true},
|
||||
{Codeless: true, JobTypes: []string{"j"}},
|
||||
{Codeless: true, DeclaredTags: []string{"t"}},
|
||||
{Codeless: true, Blocks: []*abiv1.BlockMeta{{Key: "k"}}},
|
||||
{Codeless: true, DataDir: true},
|
||||
}
|
||||
for i, m := range bad {
|
||||
if err := CodelessHookViolation(m); err == nil {
|
||||
t.Errorf("case %d not flagged", i)
|
||||
}
|
||||
}
|
||||
}
|
||||
171
internal/bnp/manifest.go
Normal file
171
internal/bnp/manifest.go
Normal file
@ -0,0 +1,171 @@
|
||||
// Package bnp implements `ninja plugin build` and `ninja plugin verify`: it
|
||||
// compiles a plugin to reactor-mode wasm, extracts its static manifest by
|
||||
// instantiating the module once and calling HOOK_DESCRIBE, packs the .bnp
|
||||
// artifact (tar.zst), and re-runs the CMS reader's layout/name/abi/path/size
|
||||
// checks standalone.
|
||||
//
|
||||
// The verify rules here are a deliberate, documented duplication of the CMS
|
||||
// reader (cms backend/plugin/bnp/reader.go, WO-WZ-008): core cannot import the
|
||||
// CMS module, so publishers get the same gate the loader applies. WO-WZ-010's
|
||||
// integration suite keeps the two in lockstep.
|
||||
package bnp
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"os"
|
||||
|
||||
abiv1 "git.dev.alexdunmow.com/block/core/abi/v1"
|
||||
"github.com/tetratelabs/wazero"
|
||||
"github.com/tetratelabs/wazero/api"
|
||||
"github.com/tetratelabs/wazero/imports/wasi_snapshot_preview1"
|
||||
"google.golang.org/protobuf/proto"
|
||||
)
|
||||
|
||||
// hostAbiVersion is the ABI major version the packer speaks when driving
|
||||
// DESCRIBE. It must equal core's guest AbiVersion / the reader's supported
|
||||
// major (1) or the guest's symmetric version gate rejects the call.
|
||||
const hostAbiVersion uint32 = 1
|
||||
|
||||
// ExtractManifest instantiates a reactor-mode plugin.wasm with wazero, drives
|
||||
// one HOOK_DESCRIBE round trip, and returns the decoded PluginManifest.
|
||||
//
|
||||
// The host functions the guest imports (blockninja.host_call) are stubbed to
|
||||
// FAIL: DESCRIBE is publish-time and must not need a live host. A plugin that
|
||||
// reaches a host capability while its manifest is being extracted (e.g. a
|
||||
// db.* call from Register) gets an actionable error naming the offending
|
||||
// method rather than a mystery hang or nil deref.
|
||||
func ExtractManifest(ctx context.Context, wasm []byte) (*abiv1.PluginManifest, error) {
|
||||
r := wazero.NewRuntime(ctx)
|
||||
defer func() { _ = r.Close(ctx) }()
|
||||
|
||||
if _, err := wasi_snapshot_preview1.Instantiate(ctx, r); err != nil {
|
||||
return nil, fmt.Errorf("instantiate wasi: %w", err)
|
||||
}
|
||||
if err := installFailingHost(ctx, r); err != nil {
|
||||
return nil, fmt.Errorf("install host stub: %w", err)
|
||||
}
|
||||
|
||||
mod, err := r.InstantiateWithConfig(ctx, wasm,
|
||||
wazero.NewModuleConfig().WithStartFunctions("_initialize").WithName("plugin"))
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("instantiate module (is it a reactor-mode wasip1 c-shared build?): %w", err)
|
||||
}
|
||||
for _, export := range []string{"bn_alloc", "bn_invoke", "bn_free"} {
|
||||
if mod.ExportedFunction(export) == nil {
|
||||
return nil, fmt.Errorf("module does not export %s — not a BlockNinja wasm guest (missing wasmguest.Serve boilerplate?)", export)
|
||||
}
|
||||
}
|
||||
|
||||
resp, err := invokeDescribe(ctx, mod)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if e := resp.GetError(); e != nil {
|
||||
return nil, fmt.Errorf("DESCRIBE failed (%s): %s", e.GetCode(), e.GetMessage())
|
||||
}
|
||||
dr := &abiv1.DescribeResponse{}
|
||||
if err := proto.Unmarshal(resp.GetPayload(), dr); err != nil {
|
||||
return nil, fmt.Errorf("decode DescribeResponse: %w", err)
|
||||
}
|
||||
m := dr.GetManifest()
|
||||
if m == nil {
|
||||
return nil, fmt.Errorf("DESCRIBE returned an empty manifest")
|
||||
}
|
||||
return m, nil
|
||||
}
|
||||
|
||||
// invokeDescribe drives one bn_alloc / bn_invoke round trip for HOOK_DESCRIBE
|
||||
// through guest linear memory, mirroring the calling convention in
|
||||
// core/docs/wasm-abi.md.
|
||||
func invokeDescribe(ctx context.Context, mod api.Module) (*abiv1.InvokeResponse, error) {
|
||||
payload, err := proto.Marshal(&abiv1.DescribeRequest{HostAbiVersion: hostAbiVersion})
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("marshal DescribeRequest: %w", err)
|
||||
}
|
||||
req, err := proto.Marshal(&abiv1.InvokeRequest{Hook: abiv1.Hook_HOOK_DESCRIBE, Payload: payload})
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("marshal InvokeRequest: %w", err)
|
||||
}
|
||||
|
||||
res, err := mod.ExportedFunction("bn_alloc").Call(ctx, uint64(len(req)))
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("bn_alloc: %w", err)
|
||||
}
|
||||
ptr := uint32(res[0])
|
||||
if ptr == 0 {
|
||||
return nil, fmt.Errorf("bn_alloc returned 0")
|
||||
}
|
||||
if !mod.Memory().Write(ptr, req) {
|
||||
return nil, fmt.Errorf("write DESCRIBE request out of range")
|
||||
}
|
||||
|
||||
res, err = mod.ExportedFunction("bn_invoke").Call(ctx,
|
||||
uint64(abiv1.Hook_HOOK_DESCRIBE), uint64(ptr), uint64(len(req)))
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("bn_invoke(DESCRIBE): %w", err)
|
||||
}
|
||||
packed := res[0]
|
||||
if packed == 0 {
|
||||
return nil, fmt.Errorf("bn_invoke returned packed 0 (guest could not produce a response envelope)")
|
||||
}
|
||||
respBytes, ok := mod.Memory().Read(uint32(packed>>32), uint32(packed))
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("read DESCRIBE response out of range")
|
||||
}
|
||||
resp := &abiv1.InvokeResponse{}
|
||||
if err := proto.Unmarshal(respBytes, resp); err != nil {
|
||||
return nil, fmt.Errorf("decode InvokeResponse: %w", err)
|
||||
}
|
||||
_, _ = mod.ExportedFunction("bn_free").Call(ctx, uint64(ptr))
|
||||
return resp, nil
|
||||
}
|
||||
|
||||
// installFailingHost exports blockninja.host_call so the guest module can be
|
||||
// instantiated, but answers every capability call with a PERMISSION_DENIED
|
||||
// AbiError naming the method — DESCRIBE must not depend on the host.
|
||||
func installFailingHost(ctx context.Context, r wazero.Runtime) error {
|
||||
_, err := r.NewHostModuleBuilder("blockninja").
|
||||
NewFunctionBuilder().
|
||||
WithFunc(func(ctx context.Context, mod api.Module, ptr, size uint32) uint64 {
|
||||
method := "<unknown>"
|
||||
if data, ok := mod.Memory().Read(ptr, size); ok {
|
||||
hcr := &abiv1.HostCallRequest{}
|
||||
if proto.Unmarshal(data, hcr) == nil && hcr.GetMethod() != "" {
|
||||
method = hcr.GetMethod()
|
||||
}
|
||||
}
|
||||
out, err := proto.Marshal(&abiv1.HostCallResponse{
|
||||
Error: &abiv1.AbiError{
|
||||
Code: abiv1.AbiErrorCode_ABI_ERROR_CODE_PERMISSION_DENIED,
|
||||
Message: fmt.Sprintf(
|
||||
"capability %q is unavailable during manifest extraction (DESCRIBE): a plugin must not call host capabilities at register/describe time",
|
||||
method),
|
||||
},
|
||||
})
|
||||
if err != nil {
|
||||
return 0
|
||||
}
|
||||
res, err := mod.ExportedFunction("bn_alloc").Call(ctx, uint64(len(out)))
|
||||
if err != nil || len(res) == 0 || res[0] == 0 {
|
||||
return 0
|
||||
}
|
||||
respPtr := uint32(res[0])
|
||||
if !mod.Memory().Write(respPtr, out) {
|
||||
return 0
|
||||
}
|
||||
return uint64(respPtr)<<32 | uint64(uint32(len(out)))
|
||||
}).
|
||||
Export("host_call").
|
||||
Instantiate(ctx)
|
||||
return err
|
||||
}
|
||||
|
||||
// readWasm is a tiny helper so callers can pass a path.
|
||||
func readWasm(path string) ([]byte, error) {
|
||||
b, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("read wasm %s: %w", path, err)
|
||||
}
|
||||
return b, nil
|
||||
}
|
||||
79
internal/bnp/mixed_test.go
Normal file
79
internal/bnp/mixed_test.go
Normal file
@ -0,0 +1,79 @@
|
||||
package bnp
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
abiv1 "git.dev.alexdunmow.com/block/core/abi/v1"
|
||||
)
|
||||
|
||||
// TestApplyManifestYAMLSupplementsWithoutWiping proves the WO-WZ-021 mixed-form
|
||||
// builder semantics: folding manifest.yaml onto a manifest that already carries
|
||||
// guest DESCRIBE output SUPPLEMENTS the declarative surfaces and OVERRIDES only
|
||||
// the keys it actually declares — an undeclared scalar key never wipes a
|
||||
// guest-populated field.
|
||||
func TestApplyManifestYAMLSupplementsWithoutWiping(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
writeFixture(t, dir, map[string]string{
|
||||
"manifest.yaml": "" +
|
||||
"bundled_fonts: fonts.json\n" +
|
||||
"page_templates:\n" +
|
||||
" - {system: blog, key: listing, title: Listing}\n" +
|
||||
"email_wrappers: [newsletter]\n",
|
||||
"fonts.json": `{"fonts":["Inter"]}`,
|
||||
"templates/blog/listing.ninjatpl": `<main>{{ title }}</main>`,
|
||||
"templates/email/newsletter.ninjatpl": `<table>{{ body|safe }}</table>`,
|
||||
})
|
||||
|
||||
// Simulate a guest DESCRIBE result: theme_presets set by the guest, plus a
|
||||
// guest-rendered page template the manifest.yaml does NOT list.
|
||||
m := &abiv1.PluginManifest{
|
||||
AbiVersion: 1,
|
||||
Name: "fixture-mixed",
|
||||
Version: "0.1.0",
|
||||
ThemePresets: []byte(`{"guest":true}`),
|
||||
PageTemplates: []*abiv1.PageTemplateMeta{
|
||||
{SystemKey: "blog", Key: "guestonly", Title: "Guest Only"},
|
||||
},
|
||||
}
|
||||
|
||||
if err := applyManifestYAML(dir, m); err != nil {
|
||||
t.Fatalf("applyManifestYAML: %v", err)
|
||||
}
|
||||
|
||||
// Undeclared theme_presets must be PRESERVED, not wiped to nil.
|
||||
if string(m.ThemePresets) != `{"guest":true}` {
|
||||
t.Errorf("theme_presets wiped/altered: %q", string(m.ThemePresets))
|
||||
}
|
||||
// Declared bundled_fonts folded in.
|
||||
if string(m.BundledFonts) != `{"fonts":["Inter"]}` {
|
||||
t.Errorf("bundled_fonts = %q", string(m.BundledFonts))
|
||||
}
|
||||
// Declared page template appended alongside the guest one (2 total).
|
||||
if len(m.PageTemplates) != 2 {
|
||||
t.Fatalf("page templates = %d, want 2 (guest + declarative)", len(m.PageTemplates))
|
||||
}
|
||||
// Declared email wrapper folded in.
|
||||
if len(m.EmailWrapperSystemKeys) != 1 || m.EmailWrapperSystemKeys[0] != "newsletter" {
|
||||
t.Errorf("email wrappers = %v", m.EmailWrapperSystemKeys)
|
||||
}
|
||||
}
|
||||
|
||||
// TestWasmBuildFoldsManifestYAML end-to-end: a repo with Go source AND a
|
||||
// manifest.yaml builds a (non-codeless) wasm artifact whose manifest.pb carries
|
||||
// the folded declarative surfaces. The absence of a manifest.yaml is a no-op —
|
||||
// covered by every existing wasm build test.
|
||||
func TestApplyManifestYAMLNoFileIsNoop(t *testing.T) {
|
||||
dir := t.TempDir() // no manifest.yaml
|
||||
m := &abiv1.PluginManifest{
|
||||
AbiVersion: 1,
|
||||
Name: "fixture-pure",
|
||||
Version: "0.1.0",
|
||||
ThemePresets: []byte(`{"guest":true}`),
|
||||
}
|
||||
if err := applyManifestYAML(dir, m); err != nil {
|
||||
t.Fatalf("applyManifestYAML (no file): %v", err)
|
||||
}
|
||||
if string(m.ThemePresets) != `{"guest":true}` {
|
||||
t.Errorf("no-manifest.yaml build mutated the manifest: %q", string(m.ThemePresets))
|
||||
}
|
||||
}
|
||||
138
internal/bnp/pack.go
Normal file
138
internal/bnp/pack.go
Normal file
@ -0,0 +1,138 @@
|
||||
package bnp
|
||||
|
||||
import (
|
||||
"archive/tar"
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"sort"
|
||||
"strings"
|
||||
|
||||
"github.com/klauspost/compress/zstd"
|
||||
)
|
||||
|
||||
// packEntry is one file destined for the artifact: its path inside the .bnp
|
||||
// (always forward-slash relative) and either literal Data or a Source file to
|
||||
// stream from.
|
||||
type packEntry struct {
|
||||
ArtifactPath string
|
||||
Data []byte
|
||||
Source string
|
||||
}
|
||||
|
||||
// packArtifact writes entries as a zstd-compressed tar to outPath. Entries are
|
||||
// sorted by artifact path for a deterministic archive. Directory entries are
|
||||
// synthesized as needed so the reader's dirExists checks fire for
|
||||
// migrations/, schemas/, assets/, web/.
|
||||
func packArtifact(outPath string, entries []packEntry) (int64, error) {
|
||||
sort.Slice(entries, func(i, j int) bool { return entries[i].ArtifactPath < entries[j].ArtifactPath })
|
||||
|
||||
out, err := os.Create(outPath)
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("create %s: %w", outPath, err)
|
||||
}
|
||||
defer func() { _ = out.Close() }()
|
||||
|
||||
enc, err := zstd.NewWriter(out, zstd.WithEncoderLevel(zstd.SpeedDefault))
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
tw := tar.NewWriter(enc)
|
||||
|
||||
seenDir := map[string]bool{}
|
||||
writeDir := func(dir string) error {
|
||||
if dir == "" || dir == "." || seenDir[dir] {
|
||||
return nil
|
||||
}
|
||||
seenDir[dir] = true
|
||||
return tw.WriteHeader(&tar.Header{
|
||||
Name: dir + "/",
|
||||
Typeflag: tar.TypeDir,
|
||||
Mode: 0o755,
|
||||
})
|
||||
}
|
||||
|
||||
var total int64
|
||||
for _, e := range entries {
|
||||
name := filepath.ToSlash(e.ArtifactPath)
|
||||
// Ensure parent directories exist as explicit entries.
|
||||
for _, d := range parentDirs(name) {
|
||||
if err := writeDir(d); err != nil {
|
||||
return 0, fmt.Errorf("write dir header %q: %w", d, err)
|
||||
}
|
||||
}
|
||||
|
||||
var data []byte
|
||||
if e.Source != "" {
|
||||
data, err = os.ReadFile(e.Source)
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("read %s: %w", e.Source, err)
|
||||
}
|
||||
} else {
|
||||
data = e.Data
|
||||
}
|
||||
if err := tw.WriteHeader(&tar.Header{
|
||||
Name: name,
|
||||
Typeflag: tar.TypeReg,
|
||||
Mode: 0o644,
|
||||
Size: int64(len(data)),
|
||||
}); err != nil {
|
||||
return 0, fmt.Errorf("write header %q: %w", name, err)
|
||||
}
|
||||
if _, err := tw.Write(data); err != nil {
|
||||
return 0, fmt.Errorf("write %q: %w", name, err)
|
||||
}
|
||||
total += int64(len(data))
|
||||
}
|
||||
|
||||
if err := tw.Close(); err != nil {
|
||||
return 0, fmt.Errorf("close tar: %w", err)
|
||||
}
|
||||
if err := enc.Close(); err != nil {
|
||||
return 0, fmt.Errorf("close zstd: %w", err)
|
||||
}
|
||||
return total, nil
|
||||
}
|
||||
|
||||
// parentDirs returns the ancestor directories of a forward-slash path, from
|
||||
// shallowest to deepest ("a/b/c.txt" → ["a", "a/b"]).
|
||||
func parentDirs(name string) []string {
|
||||
var dirs []string
|
||||
parts := strings.Split(name, "/")
|
||||
for i := 1; i < len(parts); i++ {
|
||||
dirs = append(dirs, strings.Join(parts[:i], "/"))
|
||||
}
|
||||
return dirs
|
||||
}
|
||||
|
||||
// collectDir returns pack entries for every regular file under root, mapped
|
||||
// under artifactPrefix. Symlinks and irregular files are skipped. Returns
|
||||
// (entries, hadFiles).
|
||||
func collectDir(root, artifactPrefix string) ([]packEntry, bool, error) {
|
||||
info, err := os.Stat(root)
|
||||
if err != nil || !info.IsDir() {
|
||||
return nil, false, nil //nolint:nilerr // absent optional dir is not an error
|
||||
}
|
||||
var entries []packEntry
|
||||
walkErr := filepath.WalkDir(root, func(path string, d os.DirEntry, err error) error {
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if d.IsDir() || !d.Type().IsRegular() {
|
||||
return nil
|
||||
}
|
||||
rel, err := filepath.Rel(root, path)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
entries = append(entries, packEntry{
|
||||
ArtifactPath: artifactPrefix + "/" + filepath.ToSlash(rel),
|
||||
Source: path,
|
||||
})
|
||||
return nil
|
||||
})
|
||||
if walkErr != nil {
|
||||
return nil, false, fmt.Errorf("walk %s: %w", root, walkErr)
|
||||
}
|
||||
return entries, len(entries) > 0, nil
|
||||
}
|
||||
329
internal/bnp/verify.go
Normal file
329
internal/bnp/verify.go
Normal file
@ -0,0 +1,329 @@
|
||||
package bnp
|
||||
|
||||
import (
|
||||
"archive/tar"
|
||||
"bufio"
|
||||
"bytes"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"slices"
|
||||
"strings"
|
||||
|
||||
abiv1 "git.dev.alexdunmow.com/block/core/abi/v1"
|
||||
"github.com/klauspost/compress/zstd"
|
||||
"google.golang.org/protobuf/proto"
|
||||
)
|
||||
|
||||
// These constants and the validation flow below are a DELIBERATE duplication
|
||||
// of the CMS reader (cms backend/plugin/bnp/reader.go, WO-WZ-008). core cannot
|
||||
// import the CMS module, so `ninja plugin verify` re-implements the same gate a
|
||||
// publisher's artifact will meet at load time. WO-WZ-010's integration suite
|
||||
// keeps the two copies in lockstep; change both together.
|
||||
const (
|
||||
// supportedABIMajor is the ABI major version a host understands.
|
||||
supportedABIMajor uint32 = 1
|
||||
// maxArtifactBytes caps total decompressed size (matches the registry
|
||||
// publish cap, 1 GiB) to bound a decompression bomb.
|
||||
maxArtifactBytes int64 = 1 << 30
|
||||
// maxEntryBytes caps a single extracted file.
|
||||
maxEntryBytes int64 = 512 * 1024 * 1024
|
||||
)
|
||||
|
||||
// VerifyResult reports what a valid artifact contains.
|
||||
type VerifyResult struct {
|
||||
Name string
|
||||
Version string
|
||||
ABIVersion uint32
|
||||
Codeless bool
|
||||
DataDir bool
|
||||
BlockCount int
|
||||
HasMigrations bool
|
||||
HasSchemas bool
|
||||
HasAssets bool
|
||||
HasWeb bool
|
||||
HasBlocks bool
|
||||
HasTemplates bool
|
||||
HasSeed bool
|
||||
}
|
||||
|
||||
// Verify extracts bnpPath into a temp dir and applies the reader's checks:
|
||||
// path-safety + size caps on extraction, required members present, manifest
|
||||
// decodes, abi major supported, non-empty name, and manifest name == plugin.mod
|
||||
// name. The temp dir is always cleaned up. A named error is returned for each
|
||||
// malformed class.
|
||||
func Verify(bnpPath string) (*VerifyResult, error) {
|
||||
destDir, err := os.MkdirTemp("", "ninja-verify-*")
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("bnp: temp dir: %w", err)
|
||||
}
|
||||
defer func() { _ = os.RemoveAll(destDir) }()
|
||||
|
||||
f, err := os.Open(bnpPath)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("bnp: open %s: %w", bnpPath, err)
|
||||
}
|
||||
defer func() { _ = f.Close() }()
|
||||
|
||||
if err := extractTarZst(f, destDir); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
for _, req := range []string{fileMod, fileManifest} {
|
||||
if !fileRegular(filepath.Join(destDir, req)) {
|
||||
return nil, fmt.Errorf("bnp: artifact missing required %s", req)
|
||||
}
|
||||
}
|
||||
|
||||
manifestBytes, err := os.ReadFile(filepath.Join(destDir, fileManifest))
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("bnp: read manifest.pb: %w", err)
|
||||
}
|
||||
manifest := &abiv1.PluginManifest{}
|
||||
if err := proto.Unmarshal(manifestBytes, manifest); err != nil {
|
||||
return nil, fmt.Errorf("bnp: decode manifest.pb: %w", err)
|
||||
}
|
||||
// plugin.wasm is required exactly when the manifest is NOT codeless; a
|
||||
// codeless artifact must additionally declare no computing hooks
|
||||
// (WO-WZ-020 — the classifier should have caught this at build).
|
||||
if manifest.GetCodeless() {
|
||||
if fileRegular(filepath.Join(destDir, fileWasm)) {
|
||||
return nil, errors.New("bnp: codeless manifest but plugin.wasm present — rebuild without the wasm or drop codeless")
|
||||
}
|
||||
if err := CodelessHookViolation(manifest); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
} else if !fileRegular(filepath.Join(destDir, fileWasm)) {
|
||||
return nil, fmt.Errorf("bnp: artifact missing required %s", fileWasm)
|
||||
}
|
||||
if v := manifest.GetAbiVersion(); v != supportedABIMajor {
|
||||
return nil, fmt.Errorf("bnp: unsupported abi_version %d (host supports %d)", v, supportedABIMajor)
|
||||
}
|
||||
name := manifest.GetName()
|
||||
if name == "" {
|
||||
return nil, errors.New("bnp: manifest has empty name")
|
||||
}
|
||||
|
||||
modBytes, err := os.ReadFile(filepath.Join(destDir, fileMod))
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("bnp: read plugin.mod: %w", err)
|
||||
}
|
||||
modName := parseModName(modBytes)
|
||||
if modName == "" {
|
||||
return nil, errors.New("bnp: plugin.mod has no name")
|
||||
}
|
||||
if modName != name {
|
||||
return nil, fmt.Errorf("bnp: manifest name %q != plugin.mod name %q", name, modName)
|
||||
}
|
||||
|
||||
return &VerifyResult{
|
||||
Name: name,
|
||||
Version: manifest.GetVersion(),
|
||||
ABIVersion: manifest.GetAbiVersion(),
|
||||
Codeless: manifest.GetCodeless(),
|
||||
DataDir: manifest.GetDataDir(),
|
||||
BlockCount: len(manifest.GetBlocks()),
|
||||
HasMigrations: dirExists(filepath.Join(destDir, "migrations")),
|
||||
HasSchemas: dirExists(filepath.Join(destDir, "schemas")),
|
||||
HasAssets: dirExists(filepath.Join(destDir, "assets")),
|
||||
HasWeb: dirExists(filepath.Join(destDir, "web")),
|
||||
HasBlocks: dirExists(filepath.Join(destDir, dirBlocks)),
|
||||
HasTemplates: dirExists(filepath.Join(destDir, dirTemplates)),
|
||||
HasSeed: dirExists(filepath.Join(destDir, dirSeed)),
|
||||
}, nil
|
||||
}
|
||||
|
||||
// CodelessHookViolation returns a named error when a codeless manifest
|
||||
// declares any capability that requires guest code. Mirrored by the CMS
|
||||
// reader (lockstep duplication, same as the rest of this file).
|
||||
func CodelessHookViolation(m *abiv1.PluginManifest) error {
|
||||
viol := func(what string) error {
|
||||
return fmt.Errorf("bnp: codeless manifest declares %s — that requires guest code; build a wasm plugin instead", what)
|
||||
}
|
||||
switch {
|
||||
case m.GetHasHttpHandler():
|
||||
return viol("an HTTP handler")
|
||||
case m.GetHasLoadHook() || m.GetHasUnloadHook():
|
||||
return viol("load/unload hooks")
|
||||
case m.GetHasMediaHooks():
|
||||
return viol("media hooks")
|
||||
case m.GetHasProvisioner():
|
||||
return viol("a provisioner hook")
|
||||
case len(m.GetJobTypes()) > 0:
|
||||
return viol("job handlers")
|
||||
case len(m.GetRagContentFetcherTypes()) > 0:
|
||||
return viol("RAG content fetchers")
|
||||
case len(m.GetDeclaredTags()) > 0 || len(m.GetDeclaredFilters()) > 0:
|
||||
return viol("template tags/filters (express pure snippets as template partials)")
|
||||
case len(m.GetRbacMethodRoles()) > 0 || len(m.GetCoreServiceBindings()) > 0:
|
||||
return viol("Connect services")
|
||||
case len(m.GetBlocks()) > 0 || len(m.GetTemplateKeys()) > 0:
|
||||
return viol("guest-rendered blocks/template keys (codeless blocks live in blocks/blocks.yaml; layouts are declared system/page templates rendered host-side)")
|
||||
case m.GetDirectoryExtensions().GetPanelSectionCount() > 0 || m.GetDirectoryExtensions().GetPinDecoratorCount() > 0:
|
||||
return viol("directory extension callbacks")
|
||||
case m.GetDataDir():
|
||||
return viol("a data_dir grant")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// ReadManifest extracts a .bnp into a temp dir (with the same path-safety and
|
||||
// size caps as Verify) and returns its decoded manifest.pb. It does not enforce
|
||||
// the name-match / abi checks — use Verify for the full gate.
|
||||
func ReadManifest(bnpPath string) (*abiv1.PluginManifest, error) {
|
||||
destDir, err := os.MkdirTemp("", "ninja-manifest-*")
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("bnp: temp dir: %w", err)
|
||||
}
|
||||
defer func() { _ = os.RemoveAll(destDir) }()
|
||||
|
||||
f, err := os.Open(bnpPath)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("bnp: open %s: %w", bnpPath, err)
|
||||
}
|
||||
defer func() { _ = f.Close() }()
|
||||
if err := extractTarZst(f, destDir); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
b, err := os.ReadFile(filepath.Join(destDir, fileManifest))
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("bnp: read manifest.pb: %w", err)
|
||||
}
|
||||
m := &abiv1.PluginManifest{}
|
||||
if err := proto.Unmarshal(b, m); err != nil {
|
||||
return nil, fmt.Errorf("bnp: decode manifest.pb: %w", err)
|
||||
}
|
||||
return m, nil
|
||||
}
|
||||
|
||||
// extractTarZst streams a zstd-compressed tar into destDir, rejecting
|
||||
// non-regular entries, absolute/traversal paths, and enforcing size caps.
|
||||
func extractTarZst(r io.Reader, destDir string) error {
|
||||
zr, err := zstd.NewReader(r)
|
||||
if err != nil {
|
||||
return fmt.Errorf("bnp: open zstd stream: %w", err)
|
||||
}
|
||||
defer zr.Close()
|
||||
|
||||
tr := tar.NewReader(zr)
|
||||
var total int64
|
||||
root, err := filepath.Abs(destDir)
|
||||
if err != nil {
|
||||
return fmt.Errorf("bnp: resolve dest: %w", err)
|
||||
}
|
||||
|
||||
for {
|
||||
hdr, err := tr.Next()
|
||||
if errors.Is(err, io.EOF) {
|
||||
break
|
||||
}
|
||||
if err != nil {
|
||||
return fmt.Errorf("bnp: read tar: %w", err)
|
||||
}
|
||||
|
||||
switch hdr.Typeflag {
|
||||
case tar.TypeReg, tar.TypeDir:
|
||||
default:
|
||||
return fmt.Errorf("bnp: rejected non-regular entry %q (type %d)", hdr.Name, hdr.Typeflag)
|
||||
}
|
||||
|
||||
target, err := safeJoin(root, hdr.Name)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if hdr.Typeflag == tar.TypeDir {
|
||||
if err := os.MkdirAll(target, 0o755); err != nil {
|
||||
return fmt.Errorf("bnp: mkdir %q: %w", hdr.Name, err)
|
||||
}
|
||||
continue
|
||||
}
|
||||
|
||||
if hdr.Size > maxEntryBytes {
|
||||
return fmt.Errorf("bnp: entry %q exceeds per-file cap (%d > %d)", hdr.Name, hdr.Size, maxEntryBytes)
|
||||
}
|
||||
if total+hdr.Size > maxArtifactBytes {
|
||||
return fmt.Errorf("bnp: artifact exceeds total size cap (%d)", maxArtifactBytes)
|
||||
}
|
||||
if err := os.MkdirAll(filepath.Dir(target), 0o755); err != nil {
|
||||
return fmt.Errorf("bnp: mkdir for %q: %w", hdr.Name, err)
|
||||
}
|
||||
n, err := writeExtractedFile(target, io.LimitReader(tr, maxArtifactBytes-total))
|
||||
if err != nil {
|
||||
return fmt.Errorf("bnp: extract %q: %w", hdr.Name, err)
|
||||
}
|
||||
total += n
|
||||
if total > maxArtifactBytes {
|
||||
return fmt.Errorf("bnp: artifact exceeds total size cap (%d)", maxArtifactBytes)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// safeJoin joins a relative tar entry onto root, rejecting absolute paths and
|
||||
// traversal segments.
|
||||
func safeJoin(root, name string) (string, error) {
|
||||
norm := strings.ReplaceAll(name, `\`, "/")
|
||||
if norm == "" || norm == "." {
|
||||
return "", fmt.Errorf("bnp: empty entry name %q", name)
|
||||
}
|
||||
if filepath.IsAbs(name) || strings.HasPrefix(norm, "/") {
|
||||
return "", fmt.Errorf("bnp: absolute entry path %q rejected", name)
|
||||
}
|
||||
if slices.Contains(strings.Split(norm, "/"), "..") {
|
||||
return "", fmt.Errorf("bnp: entry %q contains a traversal segment", name)
|
||||
}
|
||||
target := filepath.Join(root, filepath.Clean(norm))
|
||||
rel, err := filepath.Rel(root, target)
|
||||
if err != nil || rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) {
|
||||
return "", fmt.Errorf("bnp: entry %q escapes artifact root", name)
|
||||
}
|
||||
return target, nil
|
||||
}
|
||||
|
||||
func writeExtractedFile(path string, r io.Reader) (int64, error) {
|
||||
out, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0o644)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
n, err := io.Copy(out, r)
|
||||
closeErr := out.Close()
|
||||
if err != nil {
|
||||
return n, err
|
||||
}
|
||||
return n, closeErr
|
||||
}
|
||||
|
||||
func fileRegular(p string) bool {
|
||||
fi, err := os.Stat(p)
|
||||
return err == nil && fi.Mode().IsRegular()
|
||||
}
|
||||
|
||||
func dirExists(p string) bool {
|
||||
fi, err := os.Stat(p)
|
||||
return err == nil && fi.IsDir()
|
||||
}
|
||||
|
||||
// parseModName extracts the `name = "..."` value from a plugin.mod body,
|
||||
// mirroring the reader's tolerant line scan (works whether or not the key sits
|
||||
// under a [plugin] table).
|
||||
func parseModName(data []byte) string {
|
||||
sc := bufio.NewScanner(bytes.NewReader(data))
|
||||
for sc.Scan() {
|
||||
after, ok := strings.CutPrefix(strings.TrimSpace(sc.Text()), "name")
|
||||
if !ok {
|
||||
continue
|
||||
}
|
||||
val, ok := strings.CutPrefix(strings.TrimSpace(after), "=")
|
||||
if !ok {
|
||||
continue
|
||||
}
|
||||
val = strings.Trim(strings.TrimSpace(val), `"`)
|
||||
if val != "" {
|
||||
return val
|
||||
}
|
||||
}
|
||||
return ""
|
||||
}
|
||||
88
internal/creds/creds.go
Normal file
88
internal/creds/creds.go
Normal file
@ -0,0 +1,88 @@
|
||||
package creds
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"os"
|
||||
"path/filepath"
|
||||
)
|
||||
|
||||
type Credentials struct {
|
||||
DefaultHost string `json:"default_host"`
|
||||
Hosts map[string]HostCreds `json:"hosts"`
|
||||
}
|
||||
|
||||
type HostCreds struct {
|
||||
Token string `json:"token"`
|
||||
User string `json:"user,omitempty"`
|
||||
DefaultScope string `json:"default_scope,omitempty"`
|
||||
// ActiveAccountID is the orchestrator-side UUID of the account that
|
||||
// account-scoped commands (notably `ninja plugins publish --private`)
|
||||
// operate against. Set during `ninja login` (forced selection when the
|
||||
// user belongs to more than one account) and changeable via
|
||||
// `ninja account set`.
|
||||
ActiveAccountID string `json:"active_account_id,omitempty"`
|
||||
// ActiveAccountSlug mirrors ActiveAccountID in human-readable form for
|
||||
// display in CLI output. The orchestrator-side slug is authoritative;
|
||||
// the CLI refreshes it whenever it talks to the server.
|
||||
ActiveAccountSlug string `json:"active_account_slug,omitempty"`
|
||||
}
|
||||
|
||||
func filePath() (string, error) {
|
||||
dir, err := os.UserConfigDir()
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
return filepath.Join(dir, "ninja", "credentials.json"), nil
|
||||
}
|
||||
|
||||
func Load() (*Credentials, error) {
|
||||
p, err := filePath()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
b, err := os.ReadFile(p)
|
||||
if errors.Is(err, os.ErrNotExist) {
|
||||
return &Credentials{Hosts: map[string]HostCreds{}}, nil
|
||||
}
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
c := &Credentials{Hosts: map[string]HostCreds{}}
|
||||
if err := json.Unmarshal(b, c); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return c, nil
|
||||
}
|
||||
|
||||
func (c *Credentials) Save() error {
|
||||
p, err := filePath()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err := os.MkdirAll(filepath.Dir(p), 0o700); err != nil {
|
||||
return err
|
||||
}
|
||||
b, err := json.MarshalIndent(c, "", " ")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return os.WriteFile(p, b, 0o600)
|
||||
}
|
||||
|
||||
func (c *Credentials) Resolve(host string) (string, HostCreds, error) {
|
||||
if host == "" {
|
||||
host = c.DefaultHost
|
||||
}
|
||||
if host == "" {
|
||||
host = "https://my.blockninjacms.com"
|
||||
}
|
||||
if t := os.Getenv("NINJA_TOKEN"); t != "" {
|
||||
return host, HostCreds{Token: t}, nil
|
||||
}
|
||||
hc, ok := c.Hosts[host]
|
||||
if !ok || hc.Token == "" {
|
||||
return host, HostCreds{}, errors.New("not logged in; run `ninja login`")
|
||||
}
|
||||
return host, hc, nil
|
||||
}
|
||||
45
internal/creds/creds_test.go
Normal file
45
internal/creds/creds_test.go
Normal file
@ -0,0 +1,45 @@
|
||||
package creds
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestHostCreds_ActiveAccountRoundTrip(t *testing.T) {
|
||||
src := HostCreds{
|
||||
Token: "tok",
|
||||
ActiveAccountID: "acct-uuid",
|
||||
ActiveAccountSlug: "acme",
|
||||
}
|
||||
b, err := json.Marshal(src)
|
||||
if err != nil {
|
||||
t.Fatalf("Marshal: %v", err)
|
||||
}
|
||||
var got HostCreds
|
||||
if err := json.Unmarshal(b, &got); err != nil {
|
||||
t.Fatalf("Unmarshal: %v", err)
|
||||
}
|
||||
if got.ActiveAccountID != "acct-uuid" {
|
||||
t.Errorf("ActiveAccountID = %q, want acct-uuid", got.ActiveAccountID)
|
||||
}
|
||||
if got.ActiveAccountSlug != "acme" {
|
||||
t.Errorf("ActiveAccountSlug = %q, want acme", got.ActiveAccountSlug)
|
||||
}
|
||||
}
|
||||
|
||||
func TestHostCreds_LegacyFileLoadsWithoutAccount(t *testing.T) {
|
||||
// A creds.json from before the active-account fields existed must still
|
||||
// unmarshal cleanly; the new fields should be zero-valued.
|
||||
legacy := `{"token":"tok","user":"alice","default_scope":"@themes"}`
|
||||
var got HostCreds
|
||||
if err := json.Unmarshal([]byte(legacy), &got); err != nil {
|
||||
t.Fatalf("Unmarshal legacy: %v", err)
|
||||
}
|
||||
if got.Token != "tok" {
|
||||
t.Errorf("Token = %q", got.Token)
|
||||
}
|
||||
if got.ActiveAccountID != "" || got.ActiveAccountSlug != "" {
|
||||
t.Errorf("ActiveAccount* should be empty for legacy file, got id=%q slug=%q",
|
||||
got.ActiveAccountID, got.ActiveAccountSlug)
|
||||
}
|
||||
}
|
||||
42
internal/orchclient/client.go
Normal file
42
internal/orchclient/client.go
Normal file
@ -0,0 +1,42 @@
|
||||
package orchclient
|
||||
|
||||
import (
|
||||
"context"
|
||||
"net/http"
|
||||
|
||||
"connectrpc.com/connect"
|
||||
"git.dev.alexdunmow.com/block/cli/internal/api/orchestrator/v1/orchestratorv1connect"
|
||||
)
|
||||
|
||||
type Client struct {
|
||||
Host string
|
||||
Token string
|
||||
Auth orchestratorv1connect.PluginAuthServiceClient
|
||||
Scope orchestratorv1connect.PluginScopeServiceClient
|
||||
Reg orchestratorv1connect.PluginRegistryServiceClient
|
||||
Pub orchestratorv1connect.PluginPublishServiceClient
|
||||
}
|
||||
|
||||
func New(host, token string) *Client {
|
||||
httpClient := &http.Client{}
|
||||
opts := []connect.ClientOption{
|
||||
connect.WithInterceptors(bearerInterceptor(token)),
|
||||
}
|
||||
c := &Client{Host: host, Token: token}
|
||||
c.Auth = orchestratorv1connect.NewPluginAuthServiceClient(httpClient, host, opts...)
|
||||
c.Scope = orchestratorv1connect.NewPluginScopeServiceClient(httpClient, host, opts...)
|
||||
c.Reg = orchestratorv1connect.NewPluginRegistryServiceClient(httpClient, host, opts...)
|
||||
c.Pub = orchestratorv1connect.NewPluginPublishServiceClient(httpClient, host, opts...)
|
||||
return c
|
||||
}
|
||||
|
||||
func bearerInterceptor(token string) connect.Interceptor {
|
||||
return connect.UnaryInterceptorFunc(func(next connect.UnaryFunc) connect.UnaryFunc {
|
||||
return func(ctx context.Context, req connect.AnyRequest) (connect.AnyResponse, error) {
|
||||
if token != "" {
|
||||
req.Header().Set("Authorization", "Bearer "+token)
|
||||
}
|
||||
return next(ctx, req)
|
||||
}
|
||||
})
|
||||
}
|
||||
87
internal/shot/shot.go
Normal file
87
internal/shot/shot.go
Normal file
@ -0,0 +1,87 @@
|
||||
// Package shot captures a PNG screenshot of a rendered CMS page using a
|
||||
// headless Chromium (chromedp / CDP). It is the image-capture half of the
|
||||
// `ninja theme screenshot` harness; dojo's Playwright runner only ingests
|
||||
// pass/fail JSON, so capture lives here.
|
||||
package shot
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"net/url"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/chromedp/chromedp"
|
||||
)
|
||||
|
||||
// Options configures a single screenshot capture.
|
||||
type Options struct {
|
||||
URL string // full page URL to navigate to
|
||||
Width int // viewport width in px
|
||||
Height int // viewport height in px
|
||||
FullPage bool // capture the full scroll height, not just the viewport
|
||||
WaitSelector string // CSS selector to wait for before capturing (e.g. "section")
|
||||
Timeout time.Duration // overall navigation+capture timeout
|
||||
}
|
||||
|
||||
// PreviewURL composes the gallery-page URL with the render-only override.
|
||||
// host is the gallery site base (scheme+host), slug is the page path ("/"),
|
||||
// theme is the bare theme key written to ?preview_template.
|
||||
func PreviewURL(host, slug, theme string) string {
|
||||
host = strings.TrimRight(host, "/")
|
||||
if slug == "" {
|
||||
slug = "/"
|
||||
}
|
||||
if !strings.HasPrefix(slug, "/") {
|
||||
slug = "/" + slug
|
||||
}
|
||||
return fmt.Sprintf("%s%s?preview_template=%s", host, slug, url.QueryEscape(theme))
|
||||
}
|
||||
|
||||
// Capture navigates to opts.URL in a headless Chromium and returns PNG bytes.
|
||||
func Capture(ctx context.Context, opts Options) ([]byte, error) {
|
||||
if opts.Width == 0 {
|
||||
opts.Width = 1440
|
||||
}
|
||||
if opts.Height == 0 {
|
||||
opts.Height = 900
|
||||
}
|
||||
if opts.Timeout == 0 {
|
||||
opts.Timeout = 30 * time.Second
|
||||
}
|
||||
|
||||
allocCtx, cancelAlloc := chromedp.NewExecAllocator(ctx,
|
||||
append(chromedp.DefaultExecAllocatorOptions[:],
|
||||
chromedp.WindowSize(opts.Width, opts.Height),
|
||||
chromedp.Flag("headless", true),
|
||||
)...,
|
||||
)
|
||||
defer cancelAlloc()
|
||||
|
||||
browserCtx, cancelBrowser := chromedp.NewContext(allocCtx)
|
||||
defer cancelBrowser()
|
||||
|
||||
timeoutCtx, cancelTimeout := context.WithTimeout(browserCtx, opts.Timeout)
|
||||
defer cancelTimeout()
|
||||
|
||||
var buf []byte
|
||||
tasks := chromedp.Tasks{
|
||||
chromedp.EmulateViewport(int64(opts.Width), int64(opts.Height)),
|
||||
chromedp.Navigate(opts.URL),
|
||||
}
|
||||
if opts.WaitSelector != "" {
|
||||
tasks = append(tasks, chromedp.WaitVisible(opts.WaitSelector, chromedp.ByQuery))
|
||||
} else {
|
||||
tasks = append(tasks, chromedp.WaitReady("body", chromedp.ByQuery))
|
||||
}
|
||||
if opts.FullPage {
|
||||
tasks = append(tasks, chromedp.FullScreenshot(&buf, 90))
|
||||
} else {
|
||||
tasks = append(tasks, chromedp.CaptureScreenshot(&buf))
|
||||
}
|
||||
|
||||
if err := chromedp.Run(timeoutCtx, tasks); err != nil {
|
||||
return nil, fmt.Errorf("capture %s: %w", opts.URL, err)
|
||||
}
|
||||
return buf, nil
|
||||
}
|
||||
27
internal/shot/shot_test.go
Normal file
27
internal/shot/shot_test.go
Normal file
@ -0,0 +1,27 @@
|
||||
package shot
|
||||
|
||||
import "testing"
|
||||
|
||||
func TestPreviewURLComposesQuery(t *testing.T) {
|
||||
got := PreviewURL("https://showcase.localdev.blockninjacms.com", "/", "gotham")
|
||||
want := "https://showcase.localdev.blockninjacms.com/?preview_template=gotham"
|
||||
if got != want {
|
||||
t.Fatalf("PreviewURL = %q, want %q", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestPreviewURLTrimsTrailingSlashHost(t *testing.T) {
|
||||
got := PreviewURL("https://showcase.localdev.blockninjacms.com/", "/", "noir")
|
||||
want := "https://showcase.localdev.blockninjacms.com/?preview_template=noir"
|
||||
if got != want {
|
||||
t.Fatalf("PreviewURL = %q, want %q", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestPreviewURLNonRootSlug(t *testing.T) {
|
||||
got := PreviewURL("https://x.example.com", "/showcase", "lcars")
|
||||
want := "https://x.example.com/showcase?preview_template=lcars"
|
||||
if got != want {
|
||||
t.Fatalf("PreviewURL = %q, want %q", got, want)
|
||||
}
|
||||
}
|
||||
456
proto/orchestrator/v1/plugin_registry.proto
Normal file
456
proto/orchestrator/v1/plugin_registry.proto
Normal file
@ -0,0 +1,456 @@
|
||||
syntax = "proto3";
|
||||
|
||||
package orchestrator.v1;
|
||||
|
||||
import "google/protobuf/timestamp.proto";
|
||||
|
||||
option go_package = "git.dev.alexdunmow.com/block/cms/orchestrator/internal/api/orchestrator/v1;orchestratorv1";
|
||||
|
||||
// PluginScopeService manages @scope namespaces.
|
||||
service PluginScopeService {
|
||||
rpc CreateScope(CreateScopeRequest) returns (CreateScopeResponse);
|
||||
rpc ListMyScopes(ListMyScopesRequest) returns (ListMyScopesResponse);
|
||||
rpc GetScope(GetScopeRequest) returns (GetScopeResponse);
|
||||
rpc ListMyPlugins(ListMyPluginsRequest) returns (ListMyPluginsResponse);
|
||||
}
|
||||
|
||||
// PluginRegistryService is the read-side public API plus CreatePlugin.
|
||||
service PluginRegistryService {
|
||||
rpc CreatePlugin(CreatePluginRequest) returns (CreatePluginResponse);
|
||||
rpc GetPlugin(GetPluginRequest) returns (GetPluginResponse);
|
||||
rpc ListPlugins(ListPluginsRequest) returns (ListPluginsResponse);
|
||||
rpc GetVersion(GetVersionRequest) returns (GetVersionResponse);
|
||||
rpc ResolveInstall(ResolveInstallRequest) returns (ResolveInstallResponse);
|
||||
rpc ListCategories(ListCategoriesRequest) returns (ListCategoriesResponse);
|
||||
rpc ListTags(ListTagsRequest) returns (ListTagsResponse);
|
||||
rpc SubmitForReview(SubmitForReviewRequest) returns (SubmitForReviewResponse);
|
||||
|
||||
// Private-plugin RPCs. All require the caller to be a member of the target
|
||||
// account; the server resolves account membership from the bearer token.
|
||||
rpc ListPrivatePlugins(ListPrivatePluginsRequest) returns (ListPrivatePluginsResponse);
|
||||
rpc DeletePrivatePlugin(DeletePrivatePluginRequest) returns (DeletePrivatePluginResponse);
|
||||
rpc DeletePrivatePluginVersion(DeletePrivatePluginVersionRequest) returns (DeletePrivatePluginVersionResponse);
|
||||
rpc ListPrivatePluginInstallSites(ListPrivatePluginInstallSitesRequest) returns (ListPrivatePluginInstallSitesResponse);
|
||||
|
||||
// Instance-authenticated variants used by the CMS install/update flow. A CMS
|
||||
// instance calls these with its per-account X-CMS-Secret header plus its
|
||||
// instance_id; the server resolves the owning account from the instance and
|
||||
// authorises private plugins owned by that account. No end-user JWT is
|
||||
// required (the calling instance, not a user, is the trust unit).
|
||||
rpc ListPrivatePluginsForInstance(ListPrivatePluginsForInstanceRequest) returns (ListPrivatePluginsResponse);
|
||||
rpc ResolveInstallForInstance(ResolveInstallForInstanceRequest) returns (ResolveInstallResponse);
|
||||
}
|
||||
|
||||
// PluginModerationService is the superadmin-only side: lists pending submissions
|
||||
// and decides them. The lifecycle is: scope member CreatePlugin → PublishVersion(s)
|
||||
// → SubmitForReview → admin Approve / Reject / RequestChanges.
|
||||
service PluginModerationService {
|
||||
rpc ListPendingReviews(ListPendingReviewsRequest) returns (ListPendingReviewsResponse);
|
||||
rpc ApproveSubmission(ApproveSubmissionRequest) returns (ApproveSubmissionResponse);
|
||||
rpc RejectSubmission(RejectSubmissionRequest) returns (RejectSubmissionResponse);
|
||||
rpc RequestChanges(RequestChangesRequest) returns (RequestChangesResponse);
|
||||
}
|
||||
|
||||
// PluginPublishService is called by the ninja CLI to publish a version.
|
||||
service PluginPublishService {
|
||||
rpc PublishVersion(PublishVersionRequest) returns (PublishVersionResponse);
|
||||
}
|
||||
|
||||
// PluginAuthService handles OAuth device flow used by ninja CLI.
|
||||
service PluginAuthService {
|
||||
rpc StartDevice(StartDeviceRequest) returns (StartDeviceResponse);
|
||||
rpc PollDevice(PollDeviceRequest) returns (PollDeviceResponse);
|
||||
rpc ApproveDevice(ApproveDeviceRequest) returns (ApproveDeviceResponse);
|
||||
rpc DenyDevice(DenyDeviceRequest) returns (DenyDeviceResponse);
|
||||
rpc GetDeviceStatus(GetDeviceStatusRequest) returns (GetDeviceStatusResponse);
|
||||
rpc Whoami(WhoamiRequest) returns (WhoamiResponse);
|
||||
// ListMyAccounts is the CLI-facing account picker, returning the bare
|
||||
// minimum needed for `ninja login` / `ninja account list`. The CLI in
|
||||
// core/cmd/ninja consumes only this proto file; pulling in accounts.proto
|
||||
// and AccountService would force core to also generate bindings for the
|
||||
// full Account message and collide with the orchestrator's own copy at
|
||||
// proto-registration time.
|
||||
rpc ListMyAccountsForCLI(ListMyAccountsForCLIRequest) returns (ListMyAccountsForCLIResponse);
|
||||
}
|
||||
|
||||
// --- Shared messages ---
|
||||
|
||||
message Scope {
|
||||
string id = 1;
|
||||
string slug = 2;
|
||||
string display_name = 3;
|
||||
google.protobuf.Timestamp created_at = 4;
|
||||
}
|
||||
|
||||
// PluginVisibility is the lifecycle/access state of a plugin in the registry.
|
||||
// PRIVATE plugins are scoped to a single account; PUBLIC plugins are visible
|
||||
// to all. UNDER_REVIEW / REJECTED / TAKEN_DOWN are public-registry moderation
|
||||
// states and do not apply to private plugins.
|
||||
enum PluginVisibility {
|
||||
PLUGIN_VISIBILITY_UNSPECIFIED = 0;
|
||||
PLUGIN_VISIBILITY_PRIVATE = 1;
|
||||
PLUGIN_VISIBILITY_UNDER_REVIEW = 2;
|
||||
PLUGIN_VISIBILITY_PUBLIC = 3;
|
||||
PLUGIN_VISIBILITY_REJECTED = 4;
|
||||
PLUGIN_VISIBILITY_TAKEN_DOWN = 5;
|
||||
}
|
||||
|
||||
message Plugin {
|
||||
string id = 1;
|
||||
string scope_slug = 2;
|
||||
string name = 3;
|
||||
PluginVisibility visibility = 4;
|
||||
bool premium = 5;
|
||||
string description = 6;
|
||||
string homepage_url = 7;
|
||||
repeated string categories = 8;
|
||||
google.protobuf.Timestamp updated_at = 9;
|
||||
string kind = 10;
|
||||
string display_name = 11;
|
||||
// owner_account_id is set for private plugins and identifies the account
|
||||
// that owns the plugin. Empty for public plugins.
|
||||
string owner_account_id = 12;
|
||||
// latest_version is the most recent non-yanked version string published
|
||||
// for this plugin (e.g. "0.2.3"). Empty when the plugin has no versions
|
||||
// yet. Computed server-side as a LATERAL lookup on registry_versions so
|
||||
// listing endpoints don't N+1.
|
||||
string latest_version = 13;
|
||||
repeated string tags = 14;
|
||||
// preview_image_url is the PUBLIC, unsigned, long-lived image URL for this
|
||||
// plugin's latest non-yanked version preview (a PNG screenshot), usable
|
||||
// directly as an <img src>. Empty when no preview has been published yet —
|
||||
// the wizard card then degrades to display_name + tags (spec §5.2).
|
||||
string preview_image_url = 15;
|
||||
}
|
||||
|
||||
message Category {
|
||||
string slug = 1;
|
||||
string display_name = 2;
|
||||
string description = 3;
|
||||
int32 sort_order = 4;
|
||||
}
|
||||
|
||||
message Version {
|
||||
string id = 1;
|
||||
string plugin_id = 2;
|
||||
string version = 3;
|
||||
google.protobuf.Timestamp published_at = 6;
|
||||
bool yanked = 7;
|
||||
string sdk_constraint = 8;
|
||||
string source_archive_sha256 = 9;
|
||||
int64 source_archive_size = 10;
|
||||
// preview_image_url is the public unsigned URL of this specific version's
|
||||
// preview PNG, or empty when this version shipped no preview.png.
|
||||
string preview_image_url = 11;
|
||||
// abi_version is the wasm ABI major version this artifact was built against
|
||||
// (WO-WZ-011). 0 means a legacy source archive (compiled in-container), not a
|
||||
// .bnp. Instances filter incompatible artifacts on this before downloading.
|
||||
uint32 abi_version = 12;
|
||||
}
|
||||
|
||||
message Requirement {
|
||||
string scope_slug = 1;
|
||||
string name = 2;
|
||||
string constraint_expr = 3;
|
||||
}
|
||||
|
||||
// --- Scope service ---
|
||||
|
||||
message CreateScopeRequest { string slug = 1; string display_name = 2; }
|
||||
message CreateScopeResponse { Scope scope = 1; }
|
||||
message ListMyScopesRequest {}
|
||||
message ListMyScopesResponse { repeated Scope scopes = 1; }
|
||||
message GetScopeRequest { string slug = 1; }
|
||||
message GetScopeResponse { Scope scope = 1; repeated Plugin plugins = 2; }
|
||||
message ListMyPluginsRequest {}
|
||||
message ListMyPluginsResponse { repeated Plugin plugins = 1; }
|
||||
|
||||
// --- Registry service ---
|
||||
|
||||
message CreatePluginRequest {
|
||||
string scope_slug = 1;
|
||||
string name = 2;
|
||||
string description = 3;
|
||||
string kind = 4;
|
||||
repeated string categories = 5;
|
||||
string display_name = 6;
|
||||
// visibility is the requested visibility of the plugin. UNSPECIFIED defers
|
||||
// to the registry's default (public for explicit scopes, private for the
|
||||
// "@private" sentinel).
|
||||
PluginVisibility visibility = 7;
|
||||
// active_account_id is required when visibility = PRIVATE; the server
|
||||
// verifies the caller is a member of this account before creating the
|
||||
// private plugin under it.
|
||||
string active_account_id = 8;
|
||||
}
|
||||
message CreatePluginResponse {
|
||||
Plugin plugin = 1;
|
||||
}
|
||||
|
||||
message GetPluginRequest {
|
||||
string scope_slug = 1;
|
||||
string name = 2;
|
||||
// active_account_id is required when scope_slug = "private" so the server
|
||||
// can resolve (account_id, name) instead of (scope_id, name). Ignored
|
||||
// otherwise.
|
||||
string active_account_id = 3;
|
||||
}
|
||||
message GetPluginResponse {
|
||||
Plugin plugin = 1;
|
||||
repeated Version versions = 2;
|
||||
map<string,string> channels = 3;
|
||||
}
|
||||
|
||||
message ListPluginsRequest {
|
||||
int32 limit = 1;
|
||||
int32 offset = 2;
|
||||
string query = 3;
|
||||
string kind = 4;
|
||||
repeated string categories = 5;
|
||||
repeated string tags = 6;
|
||||
}
|
||||
message ListPluginsResponse { repeated Plugin plugins = 1; }
|
||||
|
||||
message ListCategoriesRequest {}
|
||||
message ListCategoriesResponse { repeated Category categories = 1; }
|
||||
|
||||
message ListTagsRequest {
|
||||
// Optional kind filter: "plugin", "theme", or "" for both. Lets the browse
|
||||
// UI show theme-specific tags when the user filters by kind=theme.
|
||||
string kind = 1;
|
||||
// Cap the response. 0 → server default (100).
|
||||
int32 limit = 2;
|
||||
}
|
||||
message ListTagsResponse {
|
||||
repeated TagCount tags = 1;
|
||||
}
|
||||
message TagCount {
|
||||
string tag = 1;
|
||||
int32 count = 2;
|
||||
}
|
||||
|
||||
// --- Private plugin RPC messages ---
|
||||
|
||||
message ListPrivatePluginsRequest {
|
||||
// account_id selects which account's private plugins to list. The caller
|
||||
// must be a member of this account.
|
||||
string account_id = 1;
|
||||
}
|
||||
message ListPrivatePluginsResponse {
|
||||
repeated PrivatePluginSummary plugins = 1;
|
||||
}
|
||||
|
||||
// PrivatePluginSummary is the row shape used by the publisher dashboard and
|
||||
// by the CMS "Private" installer tab. It bundles a Plugin with the latest
|
||||
// version per channel and an installation count.
|
||||
message PrivatePluginSummary {
|
||||
Plugin plugin = 1;
|
||||
// channel_versions maps channel name -> latest version string published on
|
||||
// that channel (e.g. "latest" -> "0.3.0", "beta" -> "0.4.0-beta.1").
|
||||
map<string,string> channel_versions = 2;
|
||||
// installed_site_count is the number of CMS sites in the owning account
|
||||
// that currently have any version of this plugin installed. Used to gate
|
||||
// delete-plugin in the dashboard.
|
||||
int32 installed_site_count = 3;
|
||||
}
|
||||
|
||||
message DeletePrivatePluginRequest {
|
||||
string account_id = 1;
|
||||
string plugin_name = 2;
|
||||
}
|
||||
message DeletePrivatePluginResponse {}
|
||||
|
||||
message DeletePrivatePluginVersionRequest {
|
||||
string account_id = 1;
|
||||
string plugin_name = 2;
|
||||
string version = 3;
|
||||
}
|
||||
message DeletePrivatePluginVersionResponse {}
|
||||
|
||||
message ListPrivatePluginInstallSitesRequest {
|
||||
string account_id = 1;
|
||||
string plugin_name = 2;
|
||||
}
|
||||
message ListPrivatePluginInstallSitesResponse {
|
||||
repeated PrivatePluginInstallSite sites = 1;
|
||||
}
|
||||
message PrivatePluginInstallSite {
|
||||
string instance_id = 1;
|
||||
string site_display_name = 2;
|
||||
string installed_version = 3;
|
||||
string pinned_channel = 4;
|
||||
}
|
||||
|
||||
message GetVersionRequest {
|
||||
string scope_slug = 1;
|
||||
string plugin_name = 2;
|
||||
string version = 3;
|
||||
}
|
||||
message GetVersionResponse {
|
||||
Version version = 1;
|
||||
repeated Requirement requires = 2;
|
||||
string readme_md = 3;
|
||||
string changelog_md = 4;
|
||||
}
|
||||
|
||||
message ResolveInstallRequest {
|
||||
string scope_slug = 1;
|
||||
string plugin_name = 2;
|
||||
string version_or_channel = 3;
|
||||
// active_account_id is required when scope_slug = "private" so the server
|
||||
// resolves (account_id, name) and verifies the caller's account
|
||||
// membership. Ignored for public scopes.
|
||||
string active_account_id = 4;
|
||||
}
|
||||
message ResolveInstallResponse {
|
||||
string version_id = 1;
|
||||
string scope_slug = 2;
|
||||
string plugin_name = 3;
|
||||
string version = 4;
|
||||
string channel_pinned = 5;
|
||||
string archive_url = 6;
|
||||
string archive_sha256 = 7;
|
||||
string sdk_constraint = 8;
|
||||
repeated Requirement requires = 9;
|
||||
bool yanked = 10;
|
||||
repeated string warnings = 11;
|
||||
// abi_version is the wasm ABI major of the resolved artifact (WO-WZ-011); 0
|
||||
// for a legacy source archive. The installing instance rejects an artifact
|
||||
// whose abi_version its loader cannot run.
|
||||
uint32 abi_version = 12;
|
||||
}
|
||||
|
||||
// --- Instance-authenticated request shapes ---
|
||||
// The instance proves its identity with the per-account X-CMS-Secret header;
|
||||
// instance_id selects the instance whose owning account scopes the call. No
|
||||
// active_account_id / user JWT is needed. These cover only private plugins —
|
||||
// public plugins use the anonymous ListPlugins / ResolveInstall.
|
||||
|
||||
message ListPrivatePluginsForInstanceRequest {
|
||||
string instance_id = 1;
|
||||
}
|
||||
|
||||
message ResolveInstallForInstanceRequest {
|
||||
string instance_id = 1;
|
||||
string plugin_name = 2;
|
||||
string version_or_channel = 3;
|
||||
}
|
||||
|
||||
// --- Review / moderation ---
|
||||
|
||||
message PendingReview {
|
||||
string review_id = 1;
|
||||
string plugin_id = 2;
|
||||
string scope_slug = 3;
|
||||
string plugin_name = 4;
|
||||
string plugin_display_name = 5;
|
||||
string submitted_by_user_id = 6;
|
||||
google.protobuf.Timestamp submitted_at = 7;
|
||||
}
|
||||
|
||||
message SubmitForReviewRequest {
|
||||
string plugin_id = 1;
|
||||
}
|
||||
message SubmitForReviewResponse {
|
||||
// visibility is "under_review" for non-admin authors, "public" when a superadmin
|
||||
// submits (they bypass the queue entirely). String form is preserved here for
|
||||
// backwards compatibility with existing handlers; the canonical enum is
|
||||
// PluginVisibility on the Plugin message.
|
||||
string visibility = 1;
|
||||
}
|
||||
|
||||
message ListPendingReviewsRequest {
|
||||
int32 limit = 1;
|
||||
int32 offset = 2;
|
||||
}
|
||||
message ListPendingReviewsResponse {
|
||||
repeated PendingReview reviews = 1;
|
||||
}
|
||||
|
||||
message ApproveSubmissionRequest {
|
||||
string plugin_id = 1;
|
||||
string reason = 2; // optional note for audit log
|
||||
}
|
||||
message ApproveSubmissionResponse {}
|
||||
|
||||
message RejectSubmissionRequest {
|
||||
string plugin_id = 1;
|
||||
string reason = 2; // required
|
||||
}
|
||||
message RejectSubmissionResponse {}
|
||||
|
||||
message RequestChangesRequest {
|
||||
string plugin_id = 1;
|
||||
string reason = 2; // required — author sees this verbatim
|
||||
}
|
||||
message RequestChangesResponse {}
|
||||
|
||||
// --- Publish service ---
|
||||
|
||||
message PublishVersionRequest {
|
||||
string plugin_id = 1;
|
||||
string version = 2;
|
||||
string channel = 3;
|
||||
bytes archive = 4;
|
||||
string readme_md = 5;
|
||||
string changelog_md = 6;
|
||||
}
|
||||
message PublishVersionResponse {
|
||||
Version version = 1;
|
||||
string archive_url = 2;
|
||||
repeated string warnings = 3;
|
||||
}
|
||||
|
||||
// --- Auth service (device flow) ---
|
||||
|
||||
message StartDeviceRequest { repeated string scopes = 1; }
|
||||
message StartDeviceResponse {
|
||||
string device_code = 1;
|
||||
string user_code = 2;
|
||||
string verification_uri = 3;
|
||||
int32 interval_seconds = 4;
|
||||
int32 expires_in_seconds = 5;
|
||||
}
|
||||
|
||||
message PollDeviceRequest { string device_code = 1; }
|
||||
message PollDeviceResponse {
|
||||
string access_token = 1;
|
||||
string status = 2;
|
||||
}
|
||||
|
||||
message ApproveDeviceRequest { string user_code = 1; }
|
||||
message ApproveDeviceResponse {}
|
||||
|
||||
message DenyDeviceRequest { string user_code = 1; }
|
||||
message DenyDeviceResponse {}
|
||||
|
||||
message GetDeviceStatusRequest { string user_code = 1; }
|
||||
message GetDeviceStatusResponse {
|
||||
bool valid = 1;
|
||||
bool authorized = 2;
|
||||
bool denied = 3;
|
||||
string client_id = 4;
|
||||
}
|
||||
|
||||
message WhoamiRequest {}
|
||||
message WhoamiResponse {
|
||||
string user_id = 1;
|
||||
string email = 2;
|
||||
string display_name = 3;
|
||||
}
|
||||
|
||||
// MyAccount is the slim account row returned to the CLI by
|
||||
// PluginAuthService.ListMyAccounts. The orchestrator's full Account message
|
||||
// lives in accounts.proto and carries billing, plan, status, etc.; CLI
|
||||
// account-switching needs none of that, so this shape stays minimal and
|
||||
// avoids forcing core to generate bindings for accounts.proto.
|
||||
message MyAccount {
|
||||
string id = 1;
|
||||
string slug = 2;
|
||||
string name = 3;
|
||||
}
|
||||
|
||||
message ListMyAccountsForCLIRequest {}
|
||||
message ListMyAccountsForCLIResponse {
|
||||
repeated MyAccount accounts = 1;
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user