uno.studio 3.3.0-dev.620

uno.studio

The command-line client for Uno Studio.

Its first job is building. It builds an application the way Studio builds it — headlessly, on your own machine or your own CI runner — and composes a shareable link to the result, so a reviewer can open what the build produced in a browser without installing anything.

It also lets your own git client work with Studio Projects, authenticating with the Uno Platform license already installed on your machine. It does not ask you to sign in again and it does not create any credential of its own.

Install

dotnet tool install --global uno.studio

Build an application, and share what it produced

uno-studio build --source . --out ./preview
uno-studio package link --descriptor ./preview/package-descriptor.json --published-base https://example.com/previews/1234

build compiles the application without a .NET SDK project system and writes a package plus a descriptor that describes it. The build engine it needs is downloaded on first use and cached, so a repeat build on the same machine pays nothing for it, and the engine is always the one paired with this tool's own version — never "the latest of each".

package link turns that descriptor into a link, once you have uploaded the output directory to any static hosting you control. The link pins the exact bytes the build produced, so what a reviewer opens is what the build made, and it keeps working after the release that produced it has moved on.

Useful options: --target selects the surface to build, --project picks the application when the source tree holds more than one, --strict turns the staleness warning into a failure, and --timeout-minutes bounds the run. Run either command with --help for the full set. The Uno Studio documentation covers the end-to-end CI workflow, including how to publish the output and post the link on a pull request.

Working with Projects and git

uno-studio status                     # what license will be used, and is git ready?
uno-studio setup                      # teach git how to authenticate with Studio Live
uno-studio projects list              # your Projects, with the URL to clone each one
uno-studio projects <id> clone        # or clone one directly

From then on git clone, git fetch, and git push work against your Projects like any other remote.

How setup installs the credential helper

setup writes two URL-scoped entries into your global git configuration (~/.gitconfig):

[credential "https://api.studio.platform.uno"]
    helper =
    helper = !'uno-studio' git-credential
[http "https://api.studio.platform.uno"]
    proactiveAuth = auto

• The empty first helper is deliberate. It clears any helper inherited from your system configuration — Git for Windows ships a credential manager that would otherwise answer first and could persist your license token into the OS credential store.
• The ! prefix means git hands the rest of the line to a shell and appends the operation, so the value is a command git re-executes on every credential request.
• proactiveAuth = auto lets git supply the credential before being challenged, saving one unauthenticated round trip per request. Turn it off with setup --no-proactive-auth.

Preview it without changing anything:

uno-studio setup --dry-run

It depends on uno-studio being on your PATH

The configured command is the tool name, not a path — that is what keeps the configuration working after you update the tool. This requires the global tool shim to be resolvable:

• dotnet tool install --global uno.studio puts the shim on your PATH. This is the supported setup.
• Run through dnx uno.studio or from a local tool manifest there is no shim on your PATH, so git would fail to run the helper. setup checks for this and warns; use --absolute-path to configure this executable's full path instead. Re-run setup after moving or reinstalling the tool, since a pinned path does not survive either.
• --helper-command configures an exact command, for anything the two options above do not cover.

Verifying it works

git config --get-all credential.https://api.studio.platform.uno.helper   # shows the two entries
git ls-remote https://api.studio.platform.uno/projects/<project-id>/repo # authenticates end to end

git credential fill is not a useful check: it does not request the authtype capability, so the helper warns that the credential may be ignored even when your setup is correct.

Uninstalling

uno-studio setup --remove

This clears the entries for every Studio Live service the tool knows about, not only the one currently selected — a leftover entry names a command git runs, so it would outlive the tool and then fail every operation against that service.

Commands

Run any command with --help for its full options, or uno-studio with no arguments for an interactive session. Every command returns a typed object, so --output:json (also yaml, xml, markdown) gives you a machine-readable form of any of them.

Two things worth knowing about Projects

delete stops a Project being listed; it does not erase it. The service tombstones the Project and retains its content behind its own authorization boundary. Treat the command as revoking your access to it, not as destroying the data.

A Project belongs to the account its license identifies. If a Project you expect is missing, check uno-studio status before assuming it is gone: licenses issued by different tiers resolve to different accounts, and a Project saved under one is genuinely invisible to the other.

Renaming and deleting are concurrency-safe

Both read the Project immediately before they change it and present what they read back to the service as a precondition. If someone else changed that Project in between, the command is refused rather than silently overwriting them, and tells you to re-run it. There is no flag to skip this.

Requirements

• git 2.46 or newer. Earlier versions cannot accept a bearer token from a credential helper, so setup refuses rather than writing configuration that would silently fail to authenticate.
• An Uno Platform license on this machine. If status reports none, sign in with the Uno tooling (dnx uno.devserver -- login) and run it again.

Where the license comes from

Looked up in this order:

1. --token, for a one-off override.
2. The license file the Uno Platform tooling maintains for your user account. Both the Studio-specific file and the SDK default are checked, in either spelling of the data directory the tooling has used.
3. UNO_PLATFORM_LICENSE, UNO_PLATFORM_LICENSE_TOKEN, or UNO_LICENSE_TOKEN — useful in CI.

status reports which one was used.

Security

• Your license token is never written to your git configuration. setup records only which command git should ask.
• The token is never printed. status reports where the license was found, not what it contains.
• Credentials are only ever handed to a Studio Live service, over HTTPS. The one exception is a loopback development backend, and only once you have selected it explicitly with --api-url or UNO_STUDIO_API_URL — otherwise any local process listening on that port could ask for your token.
• A credential is withheld when the server's challenge does not offer Bearer, since the token could not satisfy it anyway.
• A request for any other host goes unanswered so your other credential helpers keep working.
• store and erase do nothing: your license belongs to the Uno tooling, so a failed request never destroys it.

Environment variables