Command index

Every splent command in alphabetical order, 150 in all. Each name links to its reference page.

C · D · E · F · L · M · P · R · S · T · V · W · Make targets

This list is built from the reference pages, so it always matches them. To find the commands for one task, such as setting up a product or releasing a feature, browse the sections in the sidebar instead.


C

Command What it does
cache:clear cache:clear deletes feature entries from the cache, all of them or those of one namespace or one feature, in use or not. Then it removes the broken feature links in every product. To delete only what no product uses, run cache:prune instead.
cache:orphans cache:orphans lists the cache entries no product references, the ones cache:prune would delete. It only reads.
cache:outdated cache:outdated lists the products that declare an older version of a feature than the newest one in your local cache. It only reads. To move a product to another version, use feature:attach.
cache:prune cache:prune deletes the cache entries no product references, then the broken feature links in every product. Run it to win back disk space from old versions without touching anything in use.
cache:size cache:size shows how much disk .splent_cache/features/ takes, per namespace and per entry. Run it to find the snapshots worth removing with cache:prune or cache:clear.
cache:status cache:status lists every feature you have on disk, the pinned snapshots in .splent_cache/features/ and the editable checkouts at the workspace root, grouped by feature. Run it for an overview before you prune or clear the cache.
cache:usage cache:usage shows which products declare each feature, the reverse of cache:orphans. Run it before you remove an entry, or to see which products a new version of a feature would affect.
cache:versions cache:versions lists every cache entry of one feature, editable and versioned, from .splent_cache/features/<namespace>/. It contacts no remote.
check:contracts check:contracts checks that the feature contracts and the SPL’s UVL constraints tell the same dependency story. A dependency lives in two places, the feature’s [tool.splent.contract.requires].features and the model’s A => B. feature:install and the marketplace read the first, and product:auto-require and the configuration checks read the second.
check:deps check:deps checks that each feature’s code only uses the features the UVL model lets it depend on. A constraint A => B lets A use B. Run it after you add an import or a link to another feature.
check:docker check:docker checks that Docker and Docker Compose are installed and that the daemon answers. Run it first when product:up or product:clean fails on Docker.
check:env check:env checks the workspace environment variables and the versions of Python, the CLI and the framework. Run it when a command complains about SPLENT_APP, a token or a version mismatch.
check:features check:features checks every feature your selected product declares. It tells you where each one lives, whether its link in features/ works, whether it is installed and, for an editable one, whether its git tree is clean.
check:forge check:forge checks that the user and token of every host your features live on work against that host’s API. Run it before a release, or when a command that talks to a host answers 401 or 403.
check:infra check:infra checks the Docker declarations of your selected product and its features, without starting a container. Run it when ports clash or a service will not start.
check:product check:product checks how the features of your selected product fit together. It looks at the static links of your templates, the environment variables the features need, the feature links, the configuration keys one feature overwrites in another, and the blueprints. It only reads, so it is safe in CI.
check:pypi check:pypi checks the PyPI credentials in your workspace .env. It sends the same probe the release gate sends, so the two never disagree, and it publishes nothing. Run it before a release.
check:pyproject check:pyproject checks the pyproject.toml of your selected product. It reads its syntax, dependencies, feature lists, namespaces and SPL, and tells you what is off.
check:releases check:releases reports where the forge and PyPI disagree, for every releasable package of the workspace. Features, splent_cli, splent_framework and products are all checked. It only reads, and release:resume repairs what it finds.
check:vendor check:vendor finds Keenthemes code, the Metronic theme and its icons, in your selected product and in the features it declares. Metronic’s licence does not allow redistributing it, so no product of the line and no feature may carry it. A feature written against it also breaks once the product that ships Metronic’s files drops them.
clear:build clear:build deletes Python bytecode caches and build artifacts across the workspace. Run it before a clean test run, or when stale bytecode misbehaves after you move or rename files.
clear:log clear:log deletes $WORKING_DIR/app.log and nothing else, so rotated copies such as app.log.1 stay. It needs an active product.
clear:uploads clear:uploads empties PROTECTED_UPLOADS_DIR, where the active product’s app keeps the files it serves behind an access check. The directory itself stays, and the public files under static/ are not touched. db:reset and product:clean run it too.
command:create command:create writes the skeleton of a new CLI command in splent_cli/src/splent_cli/commands/, with its Click decorator and the cli_command export. Use it as the starting point for a command you add to splent_cli.
coverage coverage runs pytest with coverage over the modules/ folder of the selected product (SPLENT_APP), <product>/src/<product>/modules/.

D

Command What it does
db:console db:console opens an interactive MariaDB console on the selected product’s database. It takes the credentials from the product’s environment, so you never type them.
db:dump db:dump writes a SQL dump of the selected product’s MariaDB database. db:restore loads it back.
db:migrate db:migrate writes Alembic migration scripts from your model changes, for every editable feature or for one. It never applies them. Review the files, then run db:upgrade.
db:reset db:reset drops every table of the selected product’s database and applies the migrations again from scratch. Use it when the schema needs rebuilding. For fresh data on the same schema, db:seed --reset is enough.
db:restore db:restore replaces the selected product’s database with a .sql or .sql.gz dump, such as one db:dump wrote. It backs up the current database first, so you can always go back.
db:rollback db:rollback undoes a feature’s migrations, the last one by default. The features that depend on it roll back first, so no foreign key is left pointing at a dropped table.
db:seed db:seed fills the database from the seeders of the features and of the product. Each feature seeds after the features it depends on, and the product’s seeders run last. Run it after migrating, or with --reset to start over on the same schema.
db:status db:status shows, for each feature, the revision applied in the database next to the latest revision of its migration files. Run it to see what db:upgrade would apply.
db:upgrade db:upgrade applies the pending migrations of every feature, or of one. It never writes new scripts. Run it after you pull code, or after db:migrate wrote new files.
doctor doctor runs every diagnostic check of the workspace in one go and sums them up. Run it when something is broken and you do not know where to start. A failed check does not stop the others.

E

Command What it does
env:list env:list lists the variables of the workspace .env, grouped by category, with sensitive values masked. Use it for a quick overview. To find out why a variable does not behave, use env:show.
env:set env:set asks for the credentials of a host your features live on, or for your PyPI token, and writes them into the workspace .env, under the names the rest of the CLI reads. tokens:setup explains how to get each token.
env:show env:show shows each variable of the workspace .env next to what your shell exported. Use it to see why the CLI reads a value other than the file’s. For a grouped overview, use env:list.
export:puml export:puml draws your product as a PlantUML diagram. By default it draws the feature model, and it can also draw the database models, the feature dependencies or the Docker topology. It needs a selected product (SPLENT_APP).

F

Command What it does
feature:add feature:add puts a feature you are developing into the selected product, linked to its editable copy at the workspace root. Use it right after feature:create.
feature:attach feature:attach pins a released version of a feature in the selected product and installs it in the running app. Use it to adopt a release, or to move a pin to a newer one.
feature:clean feature:clean removes the scaffold your feature does not use. It reads your code to find the feature’s real archetype, then lists what feature:create wrote and you never filled in. Run it after you scaffold, or before a release.
feature:clone feature:clone copies a released version of a feature from the forge into .splent_cache, as a read-only snapshot. It adds the feature to no product, and feature:attach runs it for you when a version is missing.
feature:compat feature:compat compares the contracts of two features and tells you what would clash if a product had both. Run it before you add a feature next to another one. To check every feature of a product at once, use product:validate.
feature:compile feature:compile builds the JavaScript and CSS bundle of a feature. A feature with a frontend/ folder builds in the SPLENT toolchain image, against its own dependencies, and needs no product. Run it after you change the frontend code, or leave it watching.
feature:contract feature:contract reads your feature’s source code and infers its contract, what it provides, what it requires and what other features may extend. It compares that with the [tool.splent.contract] in the feature’s pyproject.toml, and rewrites it when you pass --write. Run it after you add a route, a hook slot or a dependency, so other features and product:validate read an accurate contract.
feature:create feature:create scaffolds a new feature at the workspace root, with only the files its type needs, as a git repository whose first commit is the scaffold. It joins no product until you run feature:add.
feature:delete feature:delete removes a versioned snapshot, <feature>@<version>, from the local cache. It changes no product, but it warns you about every product in the workspace that pins that version.
feature:detach feature:detach unpins a released version from the selected product, the reverse of feature:attach. The entry goes back to the bare, editable <namespace>/<feature>, and the feature is uninstalled from the running app. The snapshot in .splent_cache stays for the next time.
feature:discard feature:discard deletes the editable copy of a feature, the working copy at <workspace>/<feature>/. The pinned snapshots in .splent_cache stay. Use it when you are done developing a feature locally.
feature:drift feature:drift shows which scaffold files SPLENT owns in your feature differ from what the current CLI’s templates would write. It only reads. Run it after you update the CLI, then apply the changes with feature:sync-template.
feature:env feature:env shows or creates the .env in a feature’s docker/ folder. It works on the copy the product runs, editable or pinned, through the product’s symlink.
feature:fork feature:fork forks a feature from the official organisation on the forge into your account, and clones the fork into .splent_cache ready to edit. From there you can change it and release your own version.
feature:frontend-init feature:frontend-init gives a legacy feature a frontend/ of its own. From then on the SPLENT toolchain builds its bundle, against the feature’s own dependencies instead of the product’s. You run it once per feature.
feature:git feature:git runs any git command inside a feature’s folder, wherever it lives on disk. You commit and push without moving into each feature.
feature:hook-add feature:hook-add adds a template hook to an editable feature. It appends a callback stub and its register_template_hook call to hooks.py, and lists the slot in the feature’s contract.
feature:hook-remove feature:hook-remove removes a template hook from an editable feature. It deletes the register_template_hook call from hooks.py and the slot from the feature’s contract. The callback stays unless you ask for it to go.
feature:hooks feature:hooks lists the template hooks a feature registers. It reads the register_template_hook(slot, func) calls in the feature’s hooks.py.
feature:impact feature:impact shows what a feature depends on and what depends on it, directly and transitively, read from your product’s UVL constraints. Run it before you remove a feature, to see what would break, or before you add one, to see what it pulls in.
feature:info feature:info shows a feature’s contract card without cloning it. Use it to see what a feature provides and needs before you install it.
feature:inject-config feature:inject-config writes your feature’s config.py from the environment variables its code reads. The framework calls its inject_config(app) when it loads the feature, so every variable lands in app.config with its default. Run it after you add an os.getenv.
feature:install feature:install is the usual way to put a feature in your product. In one step it fetches the feature and what it requires, registers it, merges its environment variables and starts its own services.
feature:list feature:list lists the features your selected product declares in its pyproject.toml, grouped by the environment that loads them. The output is plain, so it suits scripts too.
feature:npm feature:npm runs npm in a feature’s frontend/, inside the SPLENT toolchain image, so the lock is always written by the same npm. Use it to manage the dependencies of a feature with frontend/.
feature:order feature:order shows the order in which your product loads its features. A feature always comes after the features it requires in the UVL model, and a refiner after the feature it refines. Run it to understand why one feature loads before another, or what breaks if you remove one.
feature:outdated feature:outdated compares every pinned feature of your selected product with the newest version tagged on the forge. Run it to see what you can upgrade.
feature:pin feature:pin pins every editable feature of the selected product to its newest release in .splent_cache. Run it after feature:release.
feature:pip-install feature:pip-install installs the features your product declares from PyPI, or from their git tag when PyPI does not serve them. The production image and CI run it, so you rarely run it by hand.
feature:pull feature:pull fetches your editable features, the working copies at the workspace root, and fast-forwards each one that is behind its upstream. Use it to bring every feature you develop up to date in one go. Pinned snapshots in .splent_cache are never touched.
feature:refine feature:refine turns a feature into a refiner of another one, through an interactive wizard. You pick the base and its extension points, and the wizard declares the refinement, scaffolds the code and adds the refiner to your product. Check first whether filling the base’s hook slots is enough (see Refine, extend or compose).
feature:release feature:release publishes a new version of a feature you develop at the workspace root. It checks the feature, bumps the version, uploads it to PyPI, tags and releases it on the forge, and keeps a read-only copy of the tag in the cache. Run it when your changes are ready for products to pin.
feature:remove feature:remove takes a feature out of the selected product, pinned or editable. The running app picks up the change with no restart. To keep the feature and only unpin its release, use feature:detach.
feature:rename feature:rename renames a feature you are developing, the one at the workspace root, and updates every product that uses it. It is for a feature that has not been published yet.
feature:search feature:search is another name for marketplace:search. It finds features in the marketplace index by name, by what they provide or by what they need.
feature:security feature:security lists the lines of a feature that build SQL or HTML from a string, and the template code the Content-Security-Policy blocks. The framework escapes what a template prints and binds what the ORM sends, so these are the only ways left to an SQL injection or an XSS, and no running app can catch them. Run it while you work on a feature. product:validate runs the same check on every feature of a product, and feature:release refuses a feature that fails it.
feature:status feature:status shows where each feature of the selected product is in its lifecycle, from declared to active. It reads splent.manifest.json, and it can check that state against what is really on disk and in the container. Run it when a feature does not show up in the app.
feature:sync-template feature:sync-template brings the scaffold files SPLENT owns in a feature up to the current templates, without touching your code. Run it after a CLI upgrade, when feature:drift reports a difference.
feature:test feature:test runs the tests of one feature, or of every feature of the selected product. The tests run in the product’s web container, against the product’s app or against a neutral app that holds the feature and nothing of the product. Run it while you work on a feature and before you release it.
feature:translate feature:translate extracts, creates and compiles a feature’s translations with pybabel. They live in the feature’s own translations/ folder, so they travel with it to every product. Run it after you wrap new strings in _().
feature:unlock feature:unlock turns a pinned feature into an editable one, a git working copy on main at the workspace root. The running product uses it at once. Run it when you need to change a feature your product pins.
feature:upgrade feature:upgrade moves your product’s features to the newest versions that install together and that the features’ contracts accept. pip makes the plan, a version that would rewrite a feature’s migration history is refused, the planned product is validated before anything changes, and applying changes only the pins.
feature:versions feature:versions lists the versions of a feature, from its tags on the forge and its releases on PyPI. Use it to pick a version to pin, or to see whether your product is behind.
feature:xray feature:xray shows how the features of your product fit together, read from their contracts. You see which layout slots each feature fills, what each one exposes, and what refiners override or extend. Run it when you add a refiner or a hook, or to find out who changes what in a product you did not write.

L

Command What it does
lint lint runs Ruff over the code of your workspace. Without options it only reports, and --fix fixes and reformats. It exits 2 when a check fails, so it fits a CI pipeline.
locust splent locust starts a Locust load test inside your product’s web container, which already has the framework and every feature installed. splent locust:stop stops it. Both need a selected product (SPLENT_APP) that is running.
locust:stop splent locust starts a Locust load test inside your product’s web container, which already has the framework and every feature installed. splent locust:stop stops it. Both need a selected product (SPLENT_APP) that is running.
login login logs you in to the SPLENT marketplace and keeps the token on this machine, the way docker login does. You need it only to publish SPL models with spl:publish.
logout logout revokes your marketplace token on the server and removes it from this machine. If the server cannot be reached, the token is still removed locally, so it never stays stuck on your laptop.

M

Command What it does
marketplace:index marketplace:index builds the marketplace index, one index.json with the contract of every released feature and every published SPL model. marketplace:search, feature:info and the marketplace web app read it. It is a cache, so when in doubt, rebuild it.
marketplace:search marketplace:search finds features in the marketplace index. The index knows every feature’s contract, so you can ask which features provide a service or need another feature.

P

Command What it does
product:auto-require product:auto-require adds to your pyproject.toml the features the UVL model requires and your product does not declare. It follows the A => B constraints all the way down. It needs a selected product (SPLENT_APP).
product:build product:build prepares your product for production. It checks the product, writes the deploy bundle deploy/ and the pins the image is built from, and builds the production image. Commit what it writes, and a clone of the repository deploys with docker compose alone.
product:clean product:clean resets your product completely. It stops its containers, deletes their volumes, the database included, and empties the protected uploads and the log. Use it when the environment has drifted, or when a change needs a fresh database.
product:commands product:commands lists the CLI commands your product’s features contribute, and your product’s own. It needs a selected product (SPLENT_APP) whose app boots.
product:config product:config shows the configuration your product runs with, and where each key comes from. Use it when a value is not the one you expected. It needs a selected product (SPLENT_APP).
product:configure product:configure walks the feature tree of your product’s UVL model with you, and writes the features you choose to pyproject.toml. It applies the model’s constraints as you answer, so you can only reach a valid selection. It is interactive and has no options.
product:console product:console opens a Python shell inside your product’s application context, with the database and every model already imported. Use it to look at your data without writing a single import. It needs a selected product (SPLENT_APP) and a reachable database.
product:containers product:containers shows the containers of your product and of all its features, with their state and ports. It also gives you the URLs to open, the endpoints to connect to, and how the port offset shifted each port. It needs a selected product (SPLENT_APP).
product:create product:create scaffolds a new product in the workspace. It writes the Docker files, the startup scripts, src/ and a pyproject.toml pinned to an SPL model. The product has no features yet, and nothing is installed or running.
product:deploy product:deploy runs your product in production from its deploy bundle, deploy/, the way a server that cloned the repository runs it. It also does the chores you would do by hand. It writes deploy/.env, asks for the missing secrets, frees the ports and waits until the app answers.
product:derive product:derive takes your product from its configuration to a running app in one command. It checks that the configuration is valid, then resolves, configures, builds and starts it, in development or in production. A product that fails the checks is never derived.
product:deselect product:deselect clears the active product and puts the workspace in detached mode. You need it for the commands that only run with no product selected, such as product:create and most spl:* commands.
product:down product:down stops your product and the stacks of its features. Without a flag it stops production when production is running, and development otherwise.
product:drift product:drift shows which files SPLENT owns in a product differ from the current templates. It changes nothing. product:sync-template applies the changes.
product:env product:env writes your product’s .env for one environment. --generate creates it from the product’s template, and --merge rebuilds it with the variables of every feature. product:derive runs both for you.
product:frontend-audit product:frontend-audit checks every npm package your features’ bundles ship, as one set, against npm’s advisory database. It names the features you need to release again. It needs a selected product (SPLENT_APP) and the network.
product:list product:list shows the products of your workspace, with their version and how many features each one declares. Run it to see what you can pass to product:select.
product:logs product:logs follows the logs of your product’s own containers, the Compose project <product>_<env>. It needs a selected product (SPLENT_APP). Press Ctrl+C to stop.
product:missing product:missing lists the features your SPL’s UVL model requires, through its => constraints, that your product does not declare. Run it when product:validate says the selection is not satisfiable, then add them with product:auto-require. It needs a selected product (SPLENT_APP).
product:params product:params shows every parameter your product’s features declare in [tool.splent.config_schema], the value it resolves to and the layer that decides it. It reads the files and builds no app, so it is fast and works with the product stopped. It needs a selected product (SPLENT_APP).
product:port product:port prints the URL where your product is running. It reads the port Docker actually published, so it is always the one to open.
product:release product:release publishes a new version of your product. It bumps the version, commits the deploy bundle for it, and publishes the package to PyPI, the tag and a release page to the forge, and the image to your registries. A clone of the tag then deploys with docker compose alone.
product:resolve product:resolve links every feature your product declares into <product>/features/, cloning the pinned releases the cache does not have yet. It needs a selected product (SPLENT_APP). The first resolve needs the network and can take a while, and cached releases link at once.
product:restart product:restart restarts your product’s app without recreating its containers, and waits until it answers. Run it when the hot reload missed a change, or after you change .env.
product:routes product:routes lists every HTTP route of your product with the feature that registers it. Use it to find which feature answers a URL. It needs a selected product (SPLENT_APP).
product:run product:run runs your product’s entrypoint, entrypoints/entrypoint.<env>.sh, inside its web container. The entrypoint installs the features, applies the migrations and starts the server. product:derive runs it after product:up.
product:select product:select sets the active product. Every command that works on a product, from features to containers, uses it from then on.
product:shell product:shell opens a shell in your product’s main container, or runs one command there. It needs a selected product (SPLENT_APP) and Docker running.
product:signals product:signals lists the signals your product’s features define, with the feature that emits each one and the features that listen to it. It needs a selected product (SPLENT_APP) and has no options.
product:sync-template product:sync-template brings the files SPLENT owns in a product up to the current templates, without touching your code. Those are the startup scripts, the entrypoints, the Dockerfiles, the env templates and the CI workflows. Run it after you upgrade the CLI.
product:test product:test runs a product’s tests. It runs feature:test for every feature the product declares, then the product’s own tests under tests/. It works with or without a selected product.
product:test-profile product:test-profile runs the product’s tests and shows where their time goes: per feature, per test and per fixture, and how much of it is spent on things that make tests slow without testing anything. It changes no code; it tells you what to change.
product:ui-audit product:ui-audit opens every page of your product in a real browser and looks for what tests cannot see, such as a table too wide for a phone or grey text on a dark card.
product:up product:up starts your product and the Docker stacks of its features. A feature starts once the features it depends on are healthy, unrelated features start together, and the product starts last.
product:upgrade product:upgrade moves the product’s features to their newest versions and keeps only the upgrades the running product is seen to pass with. Every upgrade is installed in the product’s container, the database is migrated, the product is validated and its tests run. An upgrade that breaks any of that is told apart from the others and left out.
product:validate product:validate checks that your product is a valid configuration of its SPL. It runs eight phases, from the UVL selection to the SQL and XSS sinks in your features’ code, and gives one verdict. Run it before you derive, build or release, and in CI.

R

Command What it does
release:cli release:cli publishes a new version of splent_cli to the git forge and PyPI, through the release pipeline. Without a version it asks which bump you want.
release:framework release:framework publishes a new version of splent_framework to the git forge and PyPI, through the release pipeline. It works like release:cli, on splent_framework/.
release:resume release:resume finishes a release that reached some channels and not others, without bumping the version. It reads the version in pyproject.toml, asks each channel what it lacks, and publishes only that. Run it when a release prints The channels have DIVERGED.

S

Command What it does
selenium End-to-end tests drive a real browser against your running product, for what functional tests cannot reach, such as JavaScript or flows across several pages. They live in each feature’s tests/e2e/ and run only when you ask.
spl:add-constraints spl:add-constraints compares what the features of a model import with the constraints the model declares, and offers to add the ones missing. Run it after changing features’ code, to keep the model in step without editing it by hand.
spl:add-feature spl:add-feature adds a feature to your product line’s model, with the constraints its code implies, so you never edit the UVL by hand.
spl:compare spl:compare puts two products of your workspace side by side, the features they share and the ones only each has. The reuse percentage in the header is a quick health signal for your product line.
spl:configurations spl:configurations counts the valid products of a line and shows which features are core, optional or dead. A dead feature, one no product can select, usually points at a contradictory constraint.
spl:create spl:create starts a new product line. It creates a working copy at the workspace root, next to your features, with a minimal UVL model you then grow with spl:add-feature.
spl:deps spl:deps shows what a feature requires according to the constraints of a model. It follows them transitively, so you get every feature a product must also select, not only the direct ones.
spl:features spl:features lists every feature of a product line’s model, sorted, with the root marked. Use it to see what a line offers before you configure a product from it.
spl:fetch spl:fetch downloads a product line’s model from UVLHub by DOI into your cache. Reading needs no account and no key. You rarely need it by hand, since every spl:* command that reads a model downloads it when it is missing.
spl:info spl:info shows everything your workspace knows about one product line. You see where the model would be read from, the pin that identifies it, and which products derive from it.
spl:list spl:list shows every product line your workspace can name, where each would be read from right now and the version it is pinned to. Run it to see what you can derive from or fetch.
spl:outdated spl:outdated tells you which products derive from an older model than one that exists. A pin by DOI keeps a build reproducible, so a product stays on its version until you move it. This command says when it has fallen behind.
spl:pin spl:pin records, by DOI, which model of its product line the active product derives from. Deriving the product then needs only its repository and UVLHub.
spl:publish spl:publish publishes your product line’s model through the marketplace and records the DOI it gets. The marketplace holds one UVLHub key for everybody, so all you need is splent login.
spl:remove-feature spl:remove-feature takes a feature out of your product line’s model, together with every constraint that names it. It is the counterpart of spl:add-feature.
storage:migrate storage:migrate moves each feature’s files into the feature’s own folder of the product’s storage. A feature names the places its files may be with register_storage_move in its init_feature, and this command empties them. The product’s start runs it after the database migrations, so you rarely type it yourself.

T

Command What it does
tokens:setup tokens:setup prints how to get the forge and PyPI tokens you need to release and to run the checks. It prints one section for the default host and one for every other host a feature of the selected product comes from, each with its own variables, scopes and token page. It takes no options.

V

Command What it does
version splent version shows the versions your workspace runs, with a fingerprint. Two workspaces with the same fingerprint run the same versions, so paste it when you report a bug or compare two machines.

W

Command What it does
whoami whoami shows who you are on the SPLENT marketplace and which token the CLI is using. Run it when a publish is refused, or when CI and your laptop disagree.
workspace:status workspace:status shows what the workspace holds: its products, its features, its product lines and the toolchain, and which products use each feature, editable or pinned.
workspace:sync workspace:sync brings the whole workspace up to date in one command. It fast-forwards every checkout at the workspace root, the framework and the CLI included, and clones every feature, product line and product of the marketplace that the workspace does not hold yet.

Make targets

These are plain make targets. They run on the host, before you are inside the CLI container. See Manage for when to use each one.

Target What it does
make cli make cli enters the running CLI container. It is your day-to-day shortcut once the container is built.
make docker-up make docker-up makes sure the workspace .env is right, then starts the CLI container without entering it. Use it in a script, or to apply your changes to docker-compose.yml.
make env-check make env-check validates the workspace .env and changes nothing. Run it when something about the environment feels off and you want the full report without starting a container.
make env-prepare make env-prepare makes sure the workspace .env exists and is correct. make setup and make docker-up run it for you. Run it alone to create the .env of a fresh clone without starting Docker.
make fix-app make fix-app clears a dangling SPLENT_APP and returns the workspace to detached mode. You need it when the prompt shows the product in yellow with a ?, which means its folder is gone, usually because you deleted or renamed it after splent product:select.
make fix-env make fix-env repairs everything it can in .env, then validates it. Run it when you want the .env right without choosing which repair to run.
make fix-workdir make fix-workdir repairs the workspace paths in .env. Product containers bind-mount the host folder that SPLENT_HOST_PROJECT_DIR names, so after you move, rename or clone the workspace again they mount the wrong directory. Run it when the pre-flight or make env-check warns about it.
make help make help lists every Make target with a one-line description. It is the default goal, so a bare make prints the same list.
make preflight make preflight runs the host checks of scripts/preflight_cli.sh and nothing else. It starts no container and changes nothing. Run it before make setup to confirm Docker is up and the .env is healthy.
make setup make setup prepares the workspace and drops you into the CLI shell in one command. Run it the first time, or whenever you want a clean, checked start. Every step is safe to repeat.
make setup-rebuild make setup-rebuild tears down the CLI environment and rebuilds it from scratch. Run it when the image is stale, after big dependency or Dockerfile changes, or when make setup starts from a broken image.

Back to top

splent. Distributed by an LGPL license v3. Contact us: drorganvidez@us.es