ample_app_delete
ChatGPTDelete 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_get
ChatGPTRead an app's deployment status
ample_app_list
ChatGPTList deployed apps, including static sites without a server
ample_app_rename
ChatGPTRename an app: --title is what the person sees, --link gives it <link>.ample.run (the old link keeps working)
ample_bucket_create
ChatGPTCreate an object-storage bucket (returns S3 credentials)
ample_bucket_credentials
ChatGPTShow the bucket's S3 credentials and endpoint
ample_bucket_delete
ChatGPTDelete a bucket and all objects in it
ample_bucket_get
ChatGPTGet bucket details (including live usage and over_quota)
ample_bucket_list
ChatGPTList buckets
ample_bucket_publish
ChatGPTServe the bucket's objects publicly (the response has public_url)
ample_bucket_put
ChatGPTWrite one object: text, base64 data, a public https URL Ample downloads, or a local file (any size; it goes straight to storage)
ample_database_create
ChatGPTCreate a managed database
ample_database_delete
ChatGPTDelete a managed database and its data. Refused while a deployment binds it
ample_database_get
ChatGPTGet database details
ample_database_list
ChatGPTList managed databases
ample_deploy
ChatGPTDeploy 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_email_disable
ChatGPTDisable new sends and immediately revoke the app's email credential
ample_email_enable
ChatGPTEnable email, automatically verify the app's ample.run domain, and return server-side integration instructions. No real email is sent. Deploy --force afterward to inject credentials
ample_email_get
ChatGPTInspect one email's status and delivery events; bodies are available only for tests
ample_email_preview
ChatGPTCapture rendered HTML/text and get a private 15-minute desktop/mobile preview link. Sends nothing. Links may contain login codes: do not share publicly
ample_email_send
ChatGPTSend a real email only when the person requests it; use preview or --test otherwise. Templates are rendered in the app. Accepted is not proof of inbox placement
ample_email_status
ChatGPTRead verification, deployment credential binding and the account's 100-email monthly allowance
ample_execution_get
ChatGPTRetrieve an existing remote execution and its result without replaying it
ample_file_put
ChatGPTPut 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_job_create
ChatGPTRun a command or an HTTP request on one of your services on a schedule The job runs inside the service's server with its environment, directory and database, whether or not the app has traffic. Give one schedule (--schedule cron with --timezone, or --every) and one target (--command, or --request for a web service; the request carries an Ample-Job-Token header equal to the app's AMPLE_JOB_TOKEN). Re-running with the same arguments changes nothing; different arguments update the job. Test it right away with ample job run <name> --wait.
ample_job_get
ChatGPTShow a job: schedule, next run, limits and its last few runs
ample_job_list
ChatGPTList scheduled jobs and when each runs next
ample_job_run
ChatGPTRun 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_runs
ChatGPTShow a job's recent runs, newest first
ample_logs
ChatGPTTail build/runtime logs for a deployment
ample_operation
ChatGPTRead an existing operation without starting another deployment
ample_plan
ChatGPTAnalyze 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_server_create
ChatGPTCreate a new server
ample_server_destroy
ChatGPTDestroy a server
ample_server_exec
ChatGPTExecute a command on a server
ample_server_keep_awake
ChatGPTKeep 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_service_delete
ChatGPTStop a service and remove it (its directory on the server is kept)
ample_service_restart
ChatGPTRestart a service, for example after updating its files
ample_service_start
ChatGPTRun 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_status
ChatGPTShow whether a service is running and how often it restarted
ample_ui_claim
ChatGPTPanel only: a link that adds an email to a temporary account.
ample_ui_identity
ChatGPTPanel only: the signed-in account.
ample_ui_logs
ChatGPTPanel only: recent build or runtime logs of an app.
ample_ui_open
ChatGPTShow 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_refresh
ChatGPTPanel only: reread the apps, the selected app and a followed deploy.
ample_ui_traffic
ChatGPTPanel only: requests to an app over the last 24 hours.
ample_upload_create
ChatGPTMake a link that takes one file into a workspace or bucket. Give page_url to the person: they open it and drop the file there. Or PUT the file to upload_url yourself (curl -T). With --deploy the workspace deploys when the file arrives. Valid for an hour
ample_upload_get
ChatGPTWhether an upload link's file has arrived, and how its deploy went
ample_workspace_create
ChatGPTCreate an account-owned source workspace (expires after seven inactive days). With --from-app it holds that live app's current source, and deploying it updates that app
ample_workspace_import
ChatGPTImport a public HTTPS Git repository into an empty workspace
ample_workspace_upload
ChatGPTReplace workspace source with a bounded tar.gz archive (preserve ample.toml and .ample when editing)
ample_workspace_write
ChatGPTWrite 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_app_delete
Claudeample_app_get
Claudeample_app_list
Claudeample_bucket_create
Claudeample_database_create
Claudeample_deploy
Claudeample_logs
Claudeample_plan
Claudeample_server_create
Claudeample_server_destroy
Claudeample_server_exec
Claudeample_service_delete
Claudeample_service_restart
Claudeample_service_start
Claudeample_service_status
Claudeample_ui_open
Claudeample_workspace_create
Claudeample_workspace_import
Claudeample_workspace_write
Claude