Pethost API

By project_id.

Projects no longer on the machine whose snapshots remain, the most recently backed up first; restore one with RunProjectAction.restore_snapshot and its project_id. Current after the machine's own backups and deletes; changes made to the backup repository elsewhere show later. Not known while Machine.snapshot_list_time is absent.

As changed.

True = include env-file values (EnvironmentVariable.secret). To edit .env: ReadPath /.env.

Only older snapshots: the oldest create_time seen, to page back. Absent = the newest.

Only snapshots holding this volume (Volume.snapshot_count). Empty = all.

New, [a-z0-9][a-z0-9_-]*, ≤63 chars; immutable.

files source: an archive from CreateTransfer.upload_archive, unpacked first. FAILED_PRECONDITION = not arrived or refused (GetUpload says which); NOT_FOUND = expired or used.

Written in order after the archive's or commit's files, as DeployProjectRequest.changes. A github source takes only /.env, e.g. text "LOG_LEVEL=debug\nTZ=UTC".

Changes to the source's x-pethost; people see metadata.name, else the id.

As DeployProject's timeout_seconds.

As DeployProject's operation_id.

files source: autofix the compose file first. With github, use source.github.autofix.

The first deploy, as the machine has it now: IN_PROGRESS, or further along for a retry of its operation_id. Absent when violations stopped it: nothing was created.

With violations: what the machine had changed, as in Operation.adjustments. A deploy that started lists them in operation.adjustments only.

With violations: a prompt for a coding agent working on the project, saying what to change in its compose file. Empty when every violation is in the .env (location "/.env"), which stays out of the repository and a person corrects.

Project.deploy_id as last read. Empty = none yet.

Applied in order to the current files, or to the new version's (with /.env and x-pethost carried over). Paths like "/compose.yaml", "/.env"; never through a symlink. /compose.yaml must result, and runs as is: pethost.compose.yaml is picked only when a version is made (CreateProject, upload_id), so writing it otherwise = INVALID_ARGUMENT. github: only /.env. Nothing to change = redeploy, a no-op while Project.x_pethost_applies_at_once (start services with RunProjectAction). RESOURCE_EXHAUSTED = too many changes or bytes: send large files with CreateTransfer.

Edits x-pethost by part, e.g. routes: Project.routes plus one. Not with a /compose.yaml change.

Written into /compose.yaml. Not with a /compose.yaml change, upload_id, or github.

For the whole deploy, builds included; 0 = default. INVALID_ARGUMENT names the bounds.

Id for the started operation: [A-Za-z0-9][A-Za-z0-9._-]*, ≤128 chars, e.g. a UUID; empty = generated. A retry with the same id returns the first call's operation, starting nothing, while the machine keeps it. ALREADY_EXISTS = it started another kind of operation. UNAVAILABLE with a ProjectBusy naming it = still starting: retry.

Autofix the archive's compose file. Only with upload_id.

The deploy, as in CreateProjectResponse. Absent when violations stopped it.

Why the files cannot be deployed: nothing changed and no operation started.

As in CreateProjectResponse: with violations only.

As in CreateProjectResponse.

The previous page's last sha. Empty = from the newest.

Newest first, at most 30.

Older ones exist: pass the last one's sha as before_commit.

As DeployProject's, for the actions that run as operations.

Set when the action runs as an operation, as the machine has it now; for set_source, the deploy it started, if any; for cancel_operation, the operation it stopped, if the machine had recorded it (see cancel_operation).

set_source: the project's source as it now is.

Empty = the latest.

≤45. 0 = answer at once.

The previous next_after_log_line; 0 = from the start. Absent = the last lines.

≤500; 0 = 50. Also ends at ~64 KiB.

Oldest first.

Lines in the whole log so far.

Pass it as after_log_line to get the lines after these; absent = 0. The machine keeps every line of the log.

Absent = a day before end_time.

Absent = now.

The range ending at end_time, e.g. 3600 = the last hour. Not with start_time.

Time series bucket width; ≤500 buckets. 0 = no series.

Requests to return, newest first; ≤200. 0 = aggregates only.

The previous next_page_token, other fields unchanged: older requests only.

The range queried, as the machine resolved it: defaults applied, on its clock.

Of the oldest request the machine keeps for the project. Absent = none is kept.

Oldest first, empty ones included.

The 10 busiest, busiest first.

The sequence of the newest request that summary, buckets and top_paths count: a request TailHttpTraffic streams with a higher one is not counted yet. 0 = none is counted.

Empty = no more requests.

Where TailHttpTraffic goes on from (after_sequence), so it misses no request newer than these: set on a first page with request_limit, empty or not. 0 = the machine had logged none.

Absent = the oldest kept.

Absent = now.

As in QueryHttpTraffic.

≤500; 0 = 100. Also ends at ~64 KiB.

False = the newest before end_time; true = the oldest after start_time.

The previous next_page_token, other fields unchanged.

The range queried, as the machine resolved it: defaults applied, on its clock.

Of the oldest line of container output the machine keeps: nothing older can be queried. Absent = none is kept.

Empty = no more.

Where TailContainerLogs goes on from (after_cursor), so it misses no line newer than these: set on every page, an empty one too. Empty = the machine had logged no line.

E.g. ["psql", "-c", "select 1"]; a shell line: ["sh", "-c", "ls | head"].

Written to stdin, then closed.

Empty = the container's. "root" can install packages.

Empty = the container's.

0 = default. Kills the main process only. Over ~50 may outlast your client: background long jobs.

True = the machine killed it at the timeout; exit_code is then -1.

The last 32 KiB of each, as the machine kept them. Invalid UTF-8, and control characters other than tab, newline and carriage return (colour codes included), become U+FFFD. Untrusted.

True = the start of stdout or stderr was cut.

The first size; the browser's resizes follow.

Empty = a login shell: bash if the image has it, else sh.

Empty = the container's user. "root" can install packages.

Empty = the container's.

E.g. "wss://m1.example.com/terminal/<ticket>"; "ws://" for a test machine's IP address.

The browser must open it before.

Absolute in the root, e.g. "/data/uploads", "/compose.yaml".

0 = 200. Also ends at ~64 KiB.

File offset.

≤1 MiB; 0 = 64 KiB.

The previous next_entry_page_token, other fields unchanged.

The path itself, symlinks followed; a symlink whose target does not exist is its own entry.

With a service root: where the path lies. Unspecified with the other roots, whose name says it.

With a service root: the volume the path lies on, when location is VOLUME. Else empty.

A directory's: directories first, then by name (bytewise).

A directory's in all.

Set = more entries follow these: pass it as entry_page_token.

A text file's contents from offset_bytes, ending on a whole character. Untrusted.

True = the file is binary (a NUL byte in its first 8 KiB): no text. Download it with CreateTransfer.

Where the next read of the file starts. 0 = the read reached its end.

With project_directory: the deploy whose files these are. To change what you read, pass it as DeployProject's base_deploy_id.

On the machine's hostname (Machine.hostname); it works once.

"PUT" or "GET".

Start the request before this.

Does it with curl, e.g. "curl --fail-with-body -T 'recipes.zip' '<url>'" or "curl --fail-with-body -o 'photo.jpg' '<url>'". For an upload, put your file's path in place of its name.

upload_archive: for CreateProject.upload_id or DeployProject.upload_id once the machine answered the PUT with 200.

upload_file: a file is at path now; the upload replaces it.

download: the name it saves as: a file's own; a directory's ends in ".tar", and "/" is named after the project and its service or volume. Empty for an upload.

From CreateTransfer.

ArchiveUpload.file_name.

Its files, as unpacked.

Of those files.

What a project of it runs: the compose file CreateProject will use ("pethost.compose.yaml", "compose.yaml", "docker-compose.yml", …), or "Dockerfile" (a compose.yaml is written for it). Empty = none of them at its root.

Its /.env: the project's unless CreateProject.files writes /.env. Empty = none. Untrusted.

Why the machine refused it, such as an entry that leads outside it: it cannot be deployed, and the fields above are empty. Empty = the machine took it.

Empty = the latest.

Empty = only lines written from now on.

To reconnect after this line.

0 = only requests from now on.

Its plan's name, e.g. "Starter".

Where it runs, e.g. "Europe". Empty = not known.

When the figures below were read.

By projects and builds.

Without page cache, as docker stats counts.

The machine's, less a reserve for the system.

The projects' disk. The operating system has its own partition outside it, and the machine's own files are left out: a new machine uses 0.

The machine's name. Log in with ssh <service>.<project_id>@<hostname>: a shell in that service's container; scp, sftp, rsync and ssh -L tunnels to the project's services work too. CreateTransfer's URLs are on it as well, and no route can take it.

"SHA256:...", to check on the first connection.

Every key logs in to every container.

True = every project is backed up nightly, and on demand.

When the machine last read the backup repository's list of snapshots whole. Absent = not yet (snapshot_list_failure_message says why, once a read failed), or backups are off: snapshot counts, Volume.last_backup_time, Project.snapshots and GetMachine.deleted_projects are then not known, rather than none.

Why the machine could not read that list, while backups are on and snapshot_list_time is absent: the backup repository's error, e.g. a wrong password or a host that does not answer. The machine keeps trying. Empty = no read has failed, or the list is known, or backups are off.

Snapshots are pruned once they are this many hours older than their project's newest. 0 = kept forever: nothing deletes them.

True = a host that no certificate installed on the machine covers gets one from Let's Encrypt once it resolves to the machine. False = such a host serves plain HTTP only.

The account's own domain, e.g. "xawro7ze.pethost.app": a route's host <name>.<apps_domain> works at once, with no DNS record of the person's (see DeployProject). Only the person changes it, in the panel's settings. Empty = there is none: every host is the person's own domain.

When an update started to need a machine restart. Absent = none is needed.

When RunMachineAction.restart_machine will restart it; later while what it waits for is still going on (RestartMachineAction.interrupt_operations). Absent = not scheduled.

What people have open in the containers now, oldest first: at most 100, the most the machine holds at once.

For RunMachineAction.end_session_id.

TUNNEL: the container's port.

The person's IP address.

Through SSH: the key they logged in with, as it was then. Empty for WEB_TERMINAL.

The web panel's terminal.

A program in a terminal, such as ssh's shell.

A program without a terminal, such as ssh ... <command> or rsync.

scp, sftp or sshfs.

One connection of an ssh -L tunnel to port.

Absent = not known: Docker cannot size the build cache.

What containers wrote outside volumes.

Project directories and operation logs.

Kept on the operating system's partition, outside disk_used_bytes; the machine bounds their age and size (QueryContainerLogsResponse.oldest_kept_time).

The HTTP request log.

The public key, as in authorized_keys: "ssh-ed25519 AAAA..."; never a private key.

Shown in the panel and session logs, e.g. "MacBook Pro".

"SHA256:...". Ignored on input.

As in https://github.com/apps/<app_name>.

The panel's page that sends a signed-in person to GitHub to install the app on their repositories, or to change which.

The repositories of the account's installations, most recently pushed first, at most 200.

In all.

False = pushes reach the panel only by its check every 5 minutes, not at once.

"owner/name".

Restore it to bring the project back as it was last backed up; GetProject then pages the older ones (snapshots_before).

In all.

Absent = now, or at_maintenance_window. INVALID_ARGUMENT = in the past.

True = the next nightly window (Machine.scheduled_restart_time). Not with restart_time.

False = wait for operations and nightly backups to end; true = cut them short.

Empty = none: people see the id.

One line.

Free text.

Most urgent first. Empty = nothing wrong.

By name.

The first route's host as a URL, e.g. "https://recipes.example.com". Empty = no route.

Every host its routes use, in the routes' order.

As in Project.

Operations in progress, newest first: a backup can run beside another one.

A github project stays on its commit: GithubSource.pinned.

Its volumes, files, what its containers wrote outside volumes, and its images: one it shares with another project counts in both. Measured every few minutes.

Empty = not about one service. DEPLOY_FAILED: the service that failed it, when one did.

DEPLOY_FAILED, DEPLOY_CANCELLED, BACKUP_FAILED, RESTORE_FAILED: the operation; GetOperation gives its log.

DEPLOY_FAILED, DEPLOY_CANCELLED, BACKUP_FAILED, RESTORE_FAILED: the operation's end. SERVICE_EXITED, RESTARTING and OUT_OF_MEMORY: when its last run ended, once it did; else its last start. AUTO_DEPLOY_REFUSED: when auto-deploy tried the commit. Absent = not known, as for UNHEALTHY.

One sentence for people, without a time of day (since_time has it), e.g. "bot fails its healthcheck: 11 failures in a row". A failed or cancelled deploy's also says whether it changed the project.

The latest deploy failed. Its operation says why, and with made_current whether its files were applied (then some containers may run the old configuration).

Running; its healthcheck fails.

Docker is restarting it, or it runs and Docker restarted it recently: likely a crash loop.

Its last run was killed for exceeding its memory, or a process of it was since it started. A loop whose runs last 10 s or more shows as RESTARTING: Docker forgets the kill when it starts it again.

The latest backup failed; its operation says why.

The latest deploy was cancelled; its operation says, with made_current, whether its files were applied.

It exited on its own with a non-zero code (Service.exit_code) and stays down: its restart policy does not restart it. A service a person stopped is no problem.

A restore failed or was cancelled, or a machine restart cut it short, and its harm remains: services it stopped are still stopped (starting them ends it); unless a restore that succeeded since replaced them, its volumes may be partly restored, and its operation's undo_snapshot_id holds them as they were. Or it brought a deleted project back, and no deploy has replaced it. The newest such restore counts; one that changed nothing does not.

Auto-deploy is on, and the machine refused the commit it last tried, the branch's newest then, which the files are not; the message says why. Each commit is tried once: fix it and push, or DeployProject with newest_commit, whose refusal gives the violations and fix_prompt.

As in ProjectSummary.

The operation_id of the deploy whose files the project has: pass it as base_deploy_id. For a deleted project brought back, the RESTORE that did it. Empty = no deploy yet.

How that operation went, or is going. Unspecified = no deploy yet.

When the current deploy made its files the project's. Absent = no deploy yet, or one that failed or was cancelled leaving no service with a container: nothing runs.

True = the current deploy succeeded and every service has a container, so a deploy whose files differ only inside x-pethost (or not at all) applies at once, with no build, pull or restart. False = the next deploy runs in full (see DeployProject).

By name.

Every one the machine holds for the project, by name.

x-pethost.routes as the machine holds them, in order: the list x_pethost.routes replaces, so send these back with your change to add, change or remove one.

Every host of the routes, in the order of its first route.

Newest first, every one the machine keeps: its newest, any still in progress, and the current deploy's (deploy_id) however old. Older ones are gone.

The newest 10, newest first, of those GetProjectRequest's snapshots_before and snapshots_volume select. Empty while backups are off or the list is not read yet (snapshot_list_time).

The project's, in all; see snapshot_list_time.

When the machine read the list of snapshots that snapshot_count, Volume.snapshot_count and Volume.last_backup_time come from (Machine.snapshot_list_time, as sampled with them). Absent = the list is not known: backups are off, or it is not read yet (Machine.snapshot_list_failure_message says why); a count of 0 then does not mean none.

Measured every few minutes.

The start_services, stop_services or restart_services that runs now, whoever called it (RunProjectAction waits for its end). Until then the project takes no other action or deploy, and Service.state is still what it was before. Absent = none.

Those it acts on.

"owner/name", one of GetMachine.github.repositories.

Empty = the default branch, also when absent on a new source.

The project's directory in it, e.g. "apps/web"; empty = the root. Outer slashes dropped; ., .. or an empty segment = INVALID_ARGUMENT.

True = deploy each new newest_commit, unless the files are it; each commit is tried once. Deploying another commit turns it off; only set_source turns it on. Default true.

Output: the branch's newest commit touching the directory, as of the last push or 5-minute check.

Output: the commit the files are at. Absent = no deploy, or the files came from another source.

True = autofix each commit's compose file (see CreateProject). Default true.

Output: deployed_commit set and auto_deploy off, e.g. after a rollback.

Output: true = auto-deploy will deploy newest_commit (not yet tried) once the project is free. A tried commit that failed or was refused waits for a person: DeployProject or a new push.

Full.

First line of its message. Untrusted.

On github.com.

True = its container runs, as RunServiceCommand, OpenTerminal and ReadPath of its own files (outside volumes) need: in RUNNING, HEALTHY and UNHEALTHY, and in STARTING once its process started.

The image as compose.yaml names it; for build: without image:, the name Compose gives.

Built on the machine from a build: section.

The registry digest it was pulled as, "sha256:...". Empty for a built image.

Absent until the machine next measures sizes, every few minutes, as after a build or pull.

What the main process runs, as compose.yaml writes it (entrypoint, then command), ${...} not interpolated, so that no value of an env file shows; the image's own argv when compose.yaml writes neither. Empty = not known without those values: compose.yaml loads only interpolated, e.g. with an include path from .env.

Of the current or last run.

Set once it exited, and while Docker waits to restart it: when, with what code (0 = a clean exit: a job that finished, or a server stopped; 137 = killed), and whether a process of it was killed for exceeding its memory.

Restarts by Docker since the container was created.

0 = no limit: it shares the machine.

0 = no limit.

Written outside volumes: lost on a recreate.

The ports it is reached at, as far as the machine knows: those compose.yaml or its image declares and those its routes send to. The project's other services reach it at <service>:<port>.

Absent = no healthcheck.

What the container is configured with, not what its image sets.

The files its env_file: names, as compose.yaml writes them, e.g. "./.env": relative to the project directory. Change them with DeployProject.changes.

Declared; no container yet.

Starting, or created while an operation that starts containers runs (deploy, recreate_service, restore); its healthcheck has not passed yet.

Running, without a healthcheck.

Running; its healthcheck passes.

Running; its healthcheck fails.

Exited and Docker is restarting it.

Not running: stopped by stop_services or a restore, never started, paused or dead.

Not running: it exited on its own (see exit_code; 0 = a job that finished).

0 = Docker picks one when the container starts.

"tcp", "udp" or "sctp".

True = bound to 127.0.0.1: reachable only through an SSH tunnel.

E.g. "/var/lib/postgresql/data".

Never restarted.

Restarted when it exits non-zero. When the machine or Docker restarts it comes back unless it exited 0 (a finished job), so one stopped with stop_services comes back too. The default when compose.yaml sets none.

Always restarted, unless stopped with RunProjectAction.stop_services.

The program and its arguments, e.g. ["curl", "-f", "http://localhost:8000/health"]; a test written as a shell line is ["/bin/sh", "-c", <line>]. Written and known as Service.command is: compose.yaml's healthcheck.test, else the image's.

How often Docker runs it.

Absent while the service is not running.

Up to the last 5 checks, oldest first.

Of the latest failed check, at most 4 KiB. Untrusted.

Absent when empty, when secret and GetProject had no include_secret_values, or when value_left_out.

True = its value is not empty and comes from an env file, directly or through ${...} in compose.yaml: env files hold the secrets. Empty values, and values written in compose.yaml itself, are not secret. The machine hides these values in operation logs too.

The file to edit to change it, absolute in the project's directory: "/compose.yaml" (the service's environment:, which wins) or the env file it comes from, e.g. "/.env", "/web.env". Empty = the machine cannot tell, as when compose.yaml takes that file's path from .env.

When compose.yaml builds it from ${...}: the .env variables to edit to change it.

True = the value is left out: the project's values together hold more than about 64 KiB. Read source_file with ReadPath.

Measured every few minutes.

Of the newest snapshot that holds this volume. Absent = no snapshot holds it, or the list is not known (Project.snapshot_list_time).

The snapshots that hold it, in all; GetProjectRequest.snapshots_volume lists them. See Project.snapshot_list_time.

False = compose.yaml no longer declares it, so no service mounts it: it keeps its data and is in every backup until RunProjectAction.delete_volume or the project is deleted. ReadPath reads it with the volume root, restore_snapshot restores it, and declaring it again mounts it as it is.

As x-pethost.routes[].host.

"https://<host>" once its certificate is served, and plain HTTP is redirected there; until then "http://<host>", which reaches the services. For AUTOMATIC, the host must resolve to the machine first.

When the certificate served expires. Absent = none is served yet.

Why the host answers nobody: a name under the panel's domain that is not one label under Machine.apps_domain (another account's, a former apps_domain of this one, or two labels deep). Change its host. Empty = it answers, or it is the person's own domain.

E.g. "recipes.example.com".

"/" = every path. Empty on input = "/".

No certificate will come: plain HTTP only. As when Machine.acme_enabled is off, or for an IP address or another name Let's Encrypt does not issue for.

A certificate installed on the machine covers it.

From Let's Encrypt, renewed automatically.

Absent while in progress.

When FAILED: why, for people. The log says more.

DEPLOY or RECREATE_SERVICE that FAILED: why, to branch on.

DEPLOY, or a RESTORE that brought a deleted project back: true = it made its files the project's. It stays true once a later deploy replaces them: Project.deploy_id names the one whose files the project has now. A deploy switches the files partway, when it starts the containers, so one that FAILED or was CANCELLED without it left the files as they were: to retry, send all its changes again with the same base_deploy_id. A project's first deploy has it from its start: its files stay however it ends, to fix and deploy again.

RECREATE_SERVICE: the service. A failed DEPLOY or RECREATE_SERVICE: the service that failed.

DEPLOY or RECREATE_SERVICE that failed CONTAINER_EXITED.

BACKUP, or DELETE's final backup, that succeeded: the snapshot taken. RESTORE: the snapshot restored.

RESTORE: the volumes it replaced.

RESTORE: the backup taken first; restore it to undo. Empty = none was taken.

DEPLOY of a github project: the commit its files are, also when it changed only /.env or x-pethost.

DEPLOY of an uploaded archive: its file name.

DEPLOY: what the machine changed to deploy that version, for people: the compose file it used, files it left out, autofix's changes.

DEPLOY: the paths its request changed, for people, the first 10: DeployProject.changes, or CreateProject's files; a move lists both paths. A commit's or an archive's own files are not listed: github_commit or archive_name says what they brought.

DEPLOY: the paths its request changed, in all.

A wrong name or tag, or a private image.

E.g. the command does not exist.

Includes a machine restart during the operation.

A ports: machine port is taken.

Exited, or kept restarting, after starting.

The image declares a VOLUME no mount covers: it would never be backed up. Mount a named volume there.

The running projects leave too little memory for a build; the message says how much.

Of its files, the directory and every volume. 0 = not known.

The volumes it holds, besides the project's directory.

5xx responses.

Of responses: WebSockets, logged when they close, count as requests but not here.

Declared in compose.yaml (NOT_FOUND lists them).

New, or one of Project.volumes, e.g. an undeclared one to remount its data.

Absolute, e.g. "/data".

Sets the fields given; an empty one is removed.

Replaces all routes.

One per host and path.

Absolute in the project's directory.

With text or data: mode 0755, not 0644; else a replaced file keeps its mode.

Empty = not about one service.

In compose.yaml, down to the key it is about, e.g. "services.db.volumes[0]", "x-pethost.routes[2].host"; or a file's absolute path, e.g. "/.env".

What is wrong and what to write instead.

The author's GitHub login, else their name. Untrusted.

When it was committed.

The project's files are this commit (GithubSource.deployed_commit).

The newest deploy of it among the operations the machine keeps; its status says how it went. Absent = none.

True = the branch's newest commit that changes the directory, as GitHub answered this call: deploying any other turns auto_deploy off (see DeployProject).

Empty = all (start: those with a container; restart: running ones).

True = pull the tag's newest image, or rebuild on the newest base images.

Existing project: the volumes to replace (≥1); it is backed up first (Operation.undo_snapshot_id), stopped and restarted; files stay. Deleted project: files, source and volumes return, then it deploys.

Required.

True = no final backup: changes since the newest snapshot are lost. Required with backups off.

From Compose, BuildKit, restic or the daemon, as LogLine.text is kept; at most 2 KiB, a longer line is cut.

As Host.host; a removed host still matches.

E.g. "GET".

Without the query; any case.

As HttpPathTraffic.path_pattern, e.g. "/recipes/*".

1-5: 5 = 5xx.

The path with id-like segments as *, e.g. "/recipes/*": requests to one endpoint.

Unique and increasing on the machine: TailHttpTraffic's cursor.

When the response finished. A WebSocket is logged when it closes, with status 0.

With the query. Untrusted.

The route that matched.

That answered. Empty = of a route the project no longer has.

0 = a WebSocket; 499 = the client left before the response.

In total.

Of which inside the service.

Untrusted.

Empty = all, removed services too.

Absent = both.

Literal, any ASCII case, ignoring escape sequences. Length limited (INVALID_ARGUMENT).

A line as written, with its colour codes (SGR escape sequences); other escape sequences, and control characters but tab, are removed. A line over 4 KiB is cut (over 16 KiB in streams). Untrusted.

Without its directory.

Of a regular file; 0 otherwise.

Permission bits in octal, e.g. "0644".

As inside the container.

When SYMLINK.

A device, socket or FIFO.

The container's own files, its image and what it wrote outside volumes, and its scratch space (an anonymous volume, a tmpfs): lost when it is recreated.

A named volume (ReadPathResponse.volume): kept across deploys and backed up.

The project's files, mounted read-only from its source as deployed: change them with DeployProject.

A zip, tar or tar.gz (told by content), e.g. "recipes.zip". A single top folder is unwrapped; .git, __MACOSX, .DS_Store, ._* are dropped.

Exactly what you will send.

Absolute in the root, e.g. "/data/uploads/a.jpg".

Exactly what you will send.

Absolute in the root.

Empty = a short action, done while its caller waits: call again in a few seconds. Else wait for it with GetOperation, even while it is still starting; when it is your own operation_id, the first call with it is still starting it: call again.

Unspecified when operation_id is empty.

Since when it holds the project.

Where the person goes on in the browser.

The person has not chosen and paid for a plan: they do it at url.

The plan is paid and a machine is being prepared for the account: Pethost emails the person when it is ready. Call again later.