plugin

type Cmd ¶

type Cmd struct {
	List    ListCmd    `cmd:"" help:"List the console's plugin catalogue + each plugin's install state in this project's lock."`
	Install InstallCmd `` /* 324-byte string literal not displayed */
	Update  UpdateCmd  `` /* 298-byte string literal not displayed */
	GenPb   GenPbCmd   `` /* 145-byte string literal not displayed */
}

Cmd is the parent of `w17ctl plugin <leaf>` commands:

• `list` — inventory of the console's catalogue + installed plugins
• `install` — fetch one plugin into the project's `<proto_dir>/plugins/` tree + record it in the lock. Two sources: a NAME, served from the console's catalogue, or a RELEASE in a repository, spelled `<repo>#<plugin>/<version>`. The fragment is the git tag itself, so what an operator types is what the repository carries. A repository install also records the commit that tag resolved to and the digest of the tree that landed, so the lock pins which BYTES were installed and not only which version number
• `update` — re-fetch one (or every) installed plugin from the console's catalogue, refreshing the on-disk tree + the lock version

`remove` is a v2 feature; until then operators manually `rm -rf <proto_dir>/plugins/<name>/` + drop the lock entry.

type GenPbCmd ¶

type GenPbCmd struct {
	Dir     string `` /* 137-byte string literal not displayed */
	Console string `` /* 175-byte string literal not displayed */
}

GenPbCmd implements `w17ctl plugin gen-pb [dir]`.

It regenerates a plugin's standalone `src/gen/pb/*.pb.go` from its `proto/` tree — the committed pb files that exist ONLY for the plugin author's local dev/test loop (`go test ./...` inside `src/`). The project codegen pipeline generates its OWN per-activation pb at staging time and never uses these files.

Thin-client model: the compile is a COMPILER concern, so it runs on the console. The client only uploads the raw proto/ tree + plugin.yaml to the GeneratePluginPb RPC, and writes the pb.go files the server returns — no buf / loader / manifest / placeholder logic client-side.

func (c *GenPbCmd) Run() error

type InstallCmd ¶

type InstallCmd struct {
	Source  string `` /* 130-byte string literal not displayed */
	Console string `` /* 214-byte string literal not displayed */
}

InstallCmd implements `w17ctl plugin install <name|url>`.

v1 supports name-only — the named plugin must exist in the console's catalogue. URLs are accepted at the argument layer to reserve the surface for v2 but rejected at the handler with a steering message.

Install:

1. Resolve the project root + lock.
2. Refuse if `<name>` is already in lock.plugins[], or if `<root>/<proto_dir>/plugins/<name>/` already exists — v1 has no `remove`, so the operator cleans up first. Both are local checks and run BEFORE the console is dialled: a repeat install should not stream a plugin tree only to refuse it.
3. Stream the plugin from the console into a sibling STAGING dir.
4. Validate the staged plugin.yaml server-side (InspectPluginManifest): manifest errors, name/dir disagreement, requirement warnings.
5. Append `PluginInstall{name, version, source: "internal"}` to the lock via EditLock (the server appends + re-signs).
6. Only then rename the staged tree into place.

func (c *InstallCmd) Run() error

type ListCmd ¶

type ListCmd struct {
	LockPath string `name:"lock" placeholder:"PATH" default:"w17/lock.yaml" help:"Path to the lock file."`
	Console  string `` /* 189-byte string literal not displayed */
}

ListCmd implements `w17ctl plugin list`. Asks the console for its plugin catalogue and cross-references the lock's `plugins[]` to surface install state. One line per plugin; reports "no plugins available" when the console serves none and the lock records none.

func (c *ListCmd) Run() error

type UpdateCmd ¶

type UpdateCmd struct {
	Name    string `arg:"" optional:"" name:"name" help:"Installed plugin to refresh. Mutually exclusive with --all."`
	All     bool   `name:"all" help:"Update every plugin recorded in lock.plugins[]."`
	To      string `` /* 238-byte string literal not displayed */
	Console string `` /* 214-byte string literal not displayed */
}

UpdateCmd implements `w17ctl plugin update <name>` and `w17ctl plugin update --all`. Both branches share the same per-plugin logic; --all just iterates over every installed plugin in the lock.

Per-plugin update:

1. Lock entry must exist for `<name>` (otherwise the operator wants `plugin install` instead).
2. The console's catalogue must carry `<name>` (URL-installed plugins can't be updated through this path).
3. The fetched manifest is validated server-side; CheckRequires runs against the running w17 version.
4. The refreshed tree is staged, then swapped in. The manifest's `version` becomes the new `lock.plugins[].version`.
5. Lock is re-signed once at the end (one save per command run regardless of how many plugins update).

func (c *UpdateCmd) Run() error