Ample

Delete an app and its releases; preserve shared servers and declared resources Apps are addressed by deployment ID, not name: a name can be shared, an ID cannot. Find it with `ample app list`.

ample_app_delete

Stop a service and remove it (its directory on the server is kept)

ample_service_delete

Deploy a local app/workspace and wait until it is live This command blocks until the release is live or fails, then exits: 0 = live, 1 = failed, 2 = blocked on a required preflight action. Ample remembers your last deploy (content-addressed), so re-running with no source or config changes is a no-op that reports the app as already live instead of rebuilding. Only re-run `ample deploy` after a real change or to retry a failure — do not poll it for status. With `--format json` the result always carries top-level `status` ("live"), `unchanged` (bool), `deployment_id`, and `server_id` fields.

ample_deploy

Destroy a server

ample_server_destroy

Read an app's deployment status

ample_app_get

Retrieve an existing remote execution and its result without replaying it

ample_execution_get

Import a public HTTPS Git repository into an empty workspace

ample_workspace_import

Keep a running server from being treated as idle for a while, e.g. during a series of commands Without --for or --release it shows what holds the server. Code inside the server can hold it too: `ample-awake -- <command>`. Holds are capped by the plan; held time is billed like any running time.

ample_server_keep_awake

Panel only: a link that adds an email to a temporary account.

ample_ui_claim

List deployed apps, including static sites without a server

ample_app_list

Show the person their Ample apps, one app (deployment_id), or the progress of a deploy started with ample_deploy or ample_up (execution_id). Read-only: it never deploys.

ample_ui_open

Analyze the repo and plan its infrastructure before deploying Detects every deployable service (monorepos included), proposes the topology (servers, databases, volumes, links), and lists open questions with options and safe defaults. Exits 0 when the plan is ready, 2 when blocking questions remain — resolve them with `--answer <path>=<value>` (or edit ample.toml) and re-run. `--write` pins the plan to a checked-in ample.toml that deploys then consume; detection still fills anything the manifest leaves unpinned.

ample_plan

Serve the bucket's objects publicly (the response has public_url)

ample_bucket_publish

Put one file into a live app (app: its name, URL or deployment id; it redeploys with the file), a workspace (workspace_id), or a bucket (bucket). file is the file the person attached, or {"download_url": "<public https URL>", "file_id": "url"} for a file on the web. path is where it goes, for example public/hero.png (defaults to the file's name). When the person has a file you cannot pass, use ample_upload_create instead.

ample_file_put

Tail build/runtime logs for a deployment

ample_logs

Panel only: reread the apps, the selected app and a followed deploy.

ample_ui_refresh

Restart a service, for example after updating its files

ample_service_restart

Execute a command on a server

ample_server_exec

Run a job now With --wait it is synchronous: it returns when the run finishes, exits 0 if it succeeded and 1 if it failed (the result has the output and, on failure, who should act and how).

ample_job_run

Show whether a service is running and how often it restarted

ample_service_status

Run a command from a directory on an existing server as a supervised service Re-running with the same arguments is a no-op; after changing files in the directory, use `ample service restart`.

ample_service_start

Write one object: text, base64 data, a public https URL Ample downloads, or a local file (any size; it goes straight to storage)

ample_bucket_put

Write a workspace file from text, base64 data, or a public https URL Ample downloads (an image, a file the person shared); --deploy then deploys the workspace

ample_workspace_write