@tonbo/cli 0.22.0 → 0.24.0

package/README.md

@@ -26,7 +26,7 @@ The login file, `login.json`, and the device id it is tied to are shared with [`
 
 ## Commands and the Management API
 
-Every command other than `login` and `logout` is named by one operation of the [Management API](../../contracts/management/openapi-v1.yaml) through its `x-tonbo-cli` and calls that operation, plus reads of the same resource (a `--wait`, the Machine a `name_taken` refusal names, the activations `machine show` reads for the last end, or the Volume a `machine create` or `update --volume` names, read for its id and region); `tonbo machine logs`, once it ships, is the named Streams exception, reading the stream at the Machine's `logs.url`. `tonbo volume move` is the one command that sends another command's operation: it reads the Volume and both Machines and sends the target's `updateMachine` with `move_from` (the `machine create --move-from` of an existing Machine, docs/design/machines-volume-move.md). Apart from it, the command set and the operations tagged with a command are the same set, which `test/commands.test.ts` checks in both directions. The CLI resolves each request from the operation table of the internal package [`@tonbo/cli-core`](../../packages/tonbo-cli-core) (`src/generated/contracts.ts`, which `pnpm --filter @tonbo/cli-core generate:contracts` derives from the contract). `login`, `logout`, `account list` and `account use` are the named exception: they obtain, choose among and discard what the other commands present as their Bearer credential. What a command may do is what your role in the account it acts in allows; the CLI never decides it.
+Every command other than `login` and `logout` is named by one operation of the [Management API](../../contracts/management/openapi-v1.yaml) through its `x-tonbo-cli` and calls that operation, plus reads of the same resource (a `--wait`, the Machine a `name_taken` refusal names, the activations `machine show` reads for the last end, the Volume a `machine create` or `update --volume` names, read for its id and region, or the Volume list `machine show` and `machine delete` read for the name of the Machine's Volume); `tonbo machine logs`, once it ships, is the named Streams exception, reading the stream at the Machine's `logs.url`. `tonbo volume move` is the one command that sends another command's operation: it reads the Volume and both Machines and sends the target's `updateMachine` with `move_from` (the `machine create --move-from` of an existing Machine, docs/design/machines-volume-move.md). Apart from it, the command set and the operations tagged with a command are the same set, which `test/commands.test.ts` checks in both directions. The CLI resolves each request from the operation table of the internal package [`@tonbo/cli-core`](../../packages/tonbo-cli-core) (`src/generated/contracts.ts`, which `pnpm --filter @tonbo/cli-core generate:contracts` derives from the contract). `login`, `logout`, `account list` and `account use` are the named exception: they obtain, choose among and discard what the other commands present as their Bearer credential. What a command may do is what your role in the account it acts in allows; the CLI never decides it.
 
 The help lives with the commands: [`src/app.ts`](src/app.ts) defines each command, its arguments and flags with their one-line descriptions, and [`src/help.ts`](src/help.ts) holds the long help, each flag's default, the examples, the shared rules and the environment. [`commands.json`](commands.json) is all of it as `--help` prints it, which the docs' CLI reference renders; `test/commands.test.ts` holds it to the program, and holds every runnable command to its details and example and the environment list to the variables the code reads, so after changing a command run `pnpm --filter @tonbo/cli commands`.
 

package/dist/bin/tonbo.js

@@ -613,6 +613,22 @@ var managementOperations = {
     "idempotencyKey": false,
     "cli": "tonbo database activity"
   },
+  "getDatabaseMetrics": {
+    "method": "GET",
+    "path": "/databases/{name}/metrics",
+    "pathParams": [
+      "name"
+    ],
+    "query": [
+      "series",
+      "window",
+      "granularity",
+      "from",
+      "to"
+    ],
+    "idempotencyKey": false,
+    "cli": "tonbo database metrics"
+  },
   "listDatabaseUsage": {
     "method": "GET",
     "path": "/usage/databases",
@@ -673,7 +689,9 @@ var managementOperations = {
     "pathParams": [
       "name"
     ],
-    "query": [],
+    "query": [
+      "delete_volume"
+    ],
     "idempotencyKey": false,
     "cli": "tonbo machine delete"
   },
@@ -687,6 +705,16 @@ var managementOperations = {
     "idempotencyKey": false,
     "cli": "tonbo machine sleep"
   },
+  "rebuildMachine": {
+    "method": "POST",
+    "path": "/machines/{name}/rebuild",
+    "pathParams": [
+      "name"
+    ],
+    "query": [],
+    "idempotencyKey": false,
+    "cli": "tonbo machine rebuild"
+  },
   "wakeMachine": {
     "method": "POST",
     "path": "/machines/{name}/wake",
@@ -740,6 +768,34 @@ var managementOperations = {
     "idempotencyKey": false,
     "cli": "tonbo metrics machines"
   },
+  "getAccountDatabaseMetrics": {
+    "method": "GET",
+    "path": "/metrics/databases",
+    "pathParams": [],
+    "query": [
+      "series",
+      "window",
+      "granularity",
+      "from",
+      "to"
+    ],
+    "idempotencyKey": false,
+    "cli": "tonbo metrics databases"
+  },
+  "getAccountStreamMetrics": {
+    "method": "GET",
+    "path": "/metrics/streams",
+    "pathParams": [],
+    "query": [
+      "series",
+      "window",
+      "granularity",
+      "from",
+      "to"
+    ],
+    "idempotencyKey": false,
+    "cli": "tonbo metrics streams"
+  },
   "listMachineShapes": {
     "method": "GET",
     "path": "/machine-shapes",
@@ -1071,6 +1127,22 @@ var managementOperations = {
     "idempotencyKey": false,
     "cli": "tonbo stream activity"
   },
+  "getStreamMetrics": {
+    "method": "GET",
+    "path": "/streams/{name}/metrics",
+    "pathParams": [
+      "name"
+    ],
+    "query": [
+      "series",
+      "window",
+      "granularity",
+      "from",
+      "to"
+    ],
+    "idempotencyKey": false,
+    "cli": "tonbo stream metrics"
+  },
   "listStreamUsage": {
     "method": "GET",
     "path": "/usage/streams",
@@ -1941,6 +2013,10 @@ var machineTimings = {
   "wakeHoldSeconds": 25,
   "earlyReclaimSeconds": 120
 };
+var machineRebuildWarning = [
+  "**Rebuild deletes changes outside /home, /workspace and /root.**",
+  "Rebuild moves this Machine to the image `<image>`. Files in /home, /workspace and /root are kept. Everything else you changed on this Machine's disk is deleted and cannot be recovered: installed packages, files you edited in /etc, global npm or pip packages, and anything in /usr, /opt or /var. To keep those changes, add them to the image's Dockerfile. The Machine sleeps now and starts on the new image at its next wake."
+];
 var machineSecretLimits = {
   "perMachine": 64,
   "valueMaxBytes": 65536,
@@ -2319,10 +2395,19 @@ var ManagementApi = class {
   deleteDatabase(key, name) {
     return this.call("deleteDatabase", key, { params: { name } });
   }
-  /** A database's writes per hour or day and its size at each step's end. */
+  /** Deprecated (`getDatabaseMetrics`): a database's writes per hour or day
+   * and its size at each step's end, for `tonbo database activity`. */
   getDatabaseActivity(key, name, query = {}) {
     return this.call("getDatabaseActivity", key, { params: { name }, query });
   }
+  /** A live database's metrics per UTC hour or day. */
+  getDatabaseMetrics(key, name, query = {}) {
+    return this.call("getDatabaseMetrics", key, { params: { name }, query });
+  }
+  /** The account's databases' metrics, each and summed. */
+  getAccountDatabaseMetrics(key, query = {}) {
+    return this.call("getAccountDatabaseMetrics", key, { query });
+  }
   /** The whole usage page: its rows, `other`, prices and checkpoint. */
   listDatabaseUsage(key, page, query = {}) {
     return this.page("listDatabaseUsage", key, page, query);
@@ -2347,10 +2432,19 @@ var ManagementApi = class {
   deleteStream(key, name) {
     return this.call("deleteStream", key, { params: { name } });
   }
-  /** A stream's appends per hour or day and its size at each step's end. */
+  /** Deprecated (`getStreamMetrics`): a stream's appends per hour or day and
+   * its size at each step's end, for `tonbo stream activity`. */
   getStreamActivity(key, name, query = {}) {
     return this.call("getStreamActivity", key, { params: { name }, query });
   }
+  /** A live stream's metrics per UTC hour or day. */
+  getStreamMetrics(key, name, query = {}) {
+    return this.call("getStreamMetrics", key, { params: { name }, query });
+  }
+  /** The account's streams' metrics, each and summed. */
+  getAccountStreamMetrics(key, query = {}) {
+    return this.call("getAccountStreamMetrics", key, { query });
+  }
   /** The whole usage page: its rows, `other`, prices and checkpoint. */
   listStreamUsage(key, page, query = {}) {
     return this.page("listStreamUsage", key, page, query);
@@ -2483,6 +2577,36 @@ var ManagementApi = class {
     const answer = await this.request("updateMachine", key, { params: { name }, body: withoutUndefined(change), ifMatch: etag });
     return { machine: answer.data, volumeMove: answer.volume_move ?? null };
   }
+  /** A Rebuild (machine-v2.json `rebuild`): `POST /machines/{name}/rebuild`
+   * with `image`, or the Machine's own reference resolved again without it.
+   * A 202 (`waiting_for_sleep`) carries the `Retry-After` to read the Machine
+   * again after; the request is then sent again once it is asleep. With
+   * `etag`, only the Machine that ETag names is rebuilt
+   * (machine-v2.json `etag.if_match.rebuild` is optional). */
+  async rebuildMachine(key, name, request, etag) {
+    const headers = { retryAfter: null };
+    const answer = await this.request("rebuildMachine", key, { params: { name }, body: withoutUndefined(request), ...etag ? { ifMatch: etag } : {} }, (response) => {
+      headers.retryAfter = response.headers.get("retry-after");
+    });
+    return {
+      machine: answer.data,
+      rebuild: answer.rebuild,
+      retryAfterSeconds: retryAfterSeconds(headers.retryAfter)
+    };
+  }
+  /** An update with `rebuild: true` and `image`, which answers as
+   * rebuildMachine does (machine-v2.json `rebuild.answers`). */
+  async updateMachineRebuild(key, name, etag, change) {
+    const headers = { retryAfter: null };
+    const answer = await this.request("updateMachine", key, { params: { name }, body: withoutUndefined({ ...change, rebuild: true }), ifMatch: etag }, (response) => {
+      headers.retryAfter = response.headers.get("retry-after");
+    });
+    return {
+      machine: answer.data,
+      rebuild: answer.rebuild,
+      retryAfterSeconds: retryAfterSeconds(headers.retryAfter)
+    };
+  }
   /** With `etag`, only the Machine that ETag names, at that revision, is put
    * to sleep (machine-v2.json `etag.if_match.sleep` is optional). A 202
    * carries the `Retry-After` to read the Machine again after
@@ -2511,14 +2635,25 @@ var ManagementApi = class {
    * says whether a name was released (`managed`: its create never reached its
    * region) or a device was forgotten (`byoc`: its region held no row). With
    * `etag`, only the Machine that ETag names is deleted
-   * (machine-v2.json `etag.if_match.delete` is optional). */
-  async deleteMachine(key, name, etag) {
+   * (machine-v2.json `etag.if_match.delete` is optional). `deleteVolume`
+   * decides the Volume a managed Machine holds (machine-v2.json
+   * `delete_volume`); without it the server's default applies, and a 202
+   * says in `volume` what became of it. */
+  async deleteMachine(key, name, etag, deleteVolume) {
     const headers = { kind: null };
-    const answer = await this.request("deleteMachine", key, { params: { name }, ...etag ? { ifMatch: etag } : {} }, (response) => {
+    const answer = await this.request("deleteMachine", key, {
+      params: { name },
+      query: { delete_volume: deleteVolume === void 0 ? void 0 : String(deleteVolume) },
+      ...etag ? { ifMatch: etag } : {}
+    }, (response) => {
       headers.kind = response.headers.get("x-tonbo-machine-kind");
     });
     if (answer?.data)
-      return { machine: answer.data, kind: answer.data.kind };
+      return {
+        machine: answer.data,
+        kind: answer.data.kind,
+        ...answer.volume === void 0 ? {} : { volume: answer.volume }
+      };
     return { machine: null, kind: headers.kind === "byoc" ? "byoc" : "managed" };
   }
   /** One page of a managed Machine's activations, newest first; the cursor
@@ -5177,6 +5312,128 @@ async function databaseActivityCommand(deps, name, options = {}) {
   );
   printActivity(deps, options.json, activity, "Database");
 }
+var REGISTRY_COLUMNS = {
+  stored_bytes: ["STORED", (value) => bytes(value)],
+  log_bytes: ["LOG", (value) => bytes(value)],
+  snapshot_bytes: ["SNAPSHOT", (value) => bytes(value)],
+  write_units: ["WRITE UNITS", String],
+  write_bytes: ["WRITTEN", (value) => bytes(value)],
+  records: ["RECORDS", String],
+  reads: ["READS", String],
+  read_bytes: ["READ", (value) => bytes(value)],
+  live_reads: ["LIVE READS", String],
+  live_read_bytes: ["LIVE READ", (value) => bytes(value)],
+  server_write_latency_p50_ms: ["WRITE P50", (value) => `${value} ms`],
+  server_write_latency_p99_ms: ["WRITE P99", (value) => `${value} ms`],
+  server_read_latency_p50_ms: ["READ P50", (value) => `${value} ms`],
+  server_read_latency_p99_ms: ["READ P99", (value) => `${value} ms`]
+};
+var SERVER_LATENCY = "Latency is server latency: measured at Tonbo's servers, from request to response headers; your network adds to this.";
+function registryMetricsTable(granularity, points) {
+  const series = Object.keys(REGISTRY_COLUMNS).filter(
+    (name) => points.some((point) => name in point)
+  );
+  return {
+    latency: series.some((name) => name.startsWith("server_")),
+    text: table(
+      [
+        granularity === "hour" ? "HOUR (UTC)" : "DAY (UTC)",
+        ...series.map((name) => REGISTRY_COLUMNS[name][0])
+      ],
+      points.map((point) => [
+        granularity === "hour" ? point.start.slice(0, 16).replace("T", " ") : point.start.slice(0, 10),
+        ...series.map((name) => {
+          const value = point[name];
+          if (value === null || value === void 0)
+            return Date.parse(point.start) > Date.now() ? "" : "-";
+          return REGISTRY_COLUMNS[name][1](value);
+        })
+      ])
+    )
+  };
+}
+function printRegistryMetrics(deps, noun, metrics, options) {
+  const rendered = registryMetricsTable(metrics.granularity, metrics.points);
+  print(
+    deps,
+    options.json,
+    metrics,
+    [
+      `${noun} ${metrics.name} in ${metrics.region} from ${metrics.from} to ${metrics.to} (UTC; metered up to ${when(metrics.as_of, "not yet metered")})`,
+      rendered.text,
+      ...rendered.latency ? [SERVER_LATENCY] : []
+    ].join("\n")
+  );
+}
+async function databaseMetricsCommand(deps, name, options = {}) {
+  const metrics = await deps.api.getDatabaseMetrics(
+    await deps.auth.apiKey(),
+    name,
+    metricsQuery(options)
+  );
+  printRegistryMetrics(deps, "Database", metrics, options);
+}
+async function streamMetricsCommand(deps, name, options = {}) {
+  const metrics = await deps.api.getStreamMetrics(
+    await deps.auth.apiKey(),
+    name,
+    metricsQuery(options)
+  );
+  printRegistryMetrics(deps, "Stream", metrics, options);
+}
+function printAccountRegistryMetrics(deps, noun, metrics, options) {
+  const rendered = registryMetricsTable(metrics.granularity, metrics.total.points);
+  const lines = [
+    `The account's ${noun} from ${metrics.from} to ${metrics.to} (UTC; metered up to ${when(metrics.as_of, "not yet metered")})`,
+    rendered.text
+  ];
+  const counted = ["write_units", "write_bytes", "records", "reads", "read_bytes"].filter((name) => metrics.total.points.some((point) => name in point));
+  const sized = metrics.total.points.some((point) => "stored_bytes" in point);
+  if (metrics.resources.length > 0 && (counted.length > 0 || sized)) {
+    lines.push(
+      "",
+      table(
+        [
+          noun === "databases" ? "DATABASE" : "STREAM",
+          "REGION",
+          ...sized ? ["STORED"] : [],
+          ...counted.map((name) => REGISTRY_COLUMNS[name][0])
+        ],
+        metrics.resources.map((resource) => {
+          const stored = [...resource.points].reverse().find((point) => point.stored_bytes !== null && point.stored_bytes !== void 0);
+          return [
+            resource.name,
+            resource.region,
+            ...sized ? [stored ? bytes(stored.stored_bytes ?? 0) : "-"] : [],
+            ...counted.map(
+              (name) => REGISTRY_COLUMNS[name][1](
+                resource.points.reduce((total, point) => total + (point[name] ?? 0), 0)
+              )
+            )
+          ];
+        })
+      )
+    );
+  }
+  if (rendered.latency) lines.push(SERVER_LATENCY);
+  if (metrics.unavailable_regions.length > 0)
+    lines.push(`Not read: ${metrics.unavailable_regions.join(", ")}`);
+  print(deps, options.json, metrics, lines.join("\n"));
+}
+async function metricsDatabasesCommand(deps, options = {}) {
+  const metrics = await deps.api.getAccountDatabaseMetrics(
+    await deps.auth.apiKey(),
+    metricsQuery(options)
+  );
+  printAccountRegistryMetrics(deps, "databases", metrics, options);
+}
+async function metricsStreamsCommand(deps, options = {}) {
+  const metrics = await deps.api.getAccountStreamMetrics(
+    await deps.auth.apiKey(),
+    metricsQuery(options)
+  );
+  printAccountRegistryMetrics(deps, "streams", metrics, options);
+}
 function streamFields(stream) {
   return fields([
     ["Name", stream.name],
@@ -5777,12 +6034,13 @@ var MACHINE_ERROR_HINTS = {
   machine_kind_mismatch: "That Machine is one of your computers: `tonbo machine show` and `tonbo machine delete` serve it, and nothing else does.",
   volumes_not_offered: "Volumes are not offered to this account in the Machine's region yet; nothing was created or changed.",
   root_mode_not_offered: "A Volume as the Machine's whole disk is not offered to this account yet; nothing was created or changed. Mount it at a path instead: --volume <name>:<path>.",
-  rebuild_required: "This Machine's Volume is its whole disk, so its image changes only by Rebuild, which keeps /home, /workspace and /root and deletes every other change on the disk. Rebuild is not available yet: keep the image, or create a new Machine with the new image and a new Volume.",
-  volume_mode_change: "The Volume cannot move between being the Machine's whole disk and being mounted at a path; nothing was changed. Bind a new Volume in the mode you want.",
+  rebuild_required: "This Machine's Volume is its whole disk, so its image changes only by Rebuild; nothing was changed. Once you have read what Rebuild deletes, run `tonbo machine rebuild <name> --image <reference>`, or the same update with --rebuild.",
+  volume_not_whole_disk: "This Machine's Volume is mounted at a path, or it has none, so it needs no Rebuild; nothing was changed. Change its image with `tonbo machine update <name> --image <reference>`.",
+  volume_mode_change: "A Machine's whole disk is never mounted at a path, and a Volume mounted at a path becomes a whole disk only on its own Machine; nothing was changed.",
   volume_attached: "The Machine the message names is awake with the Volume attached; nothing was changed. Put it to sleep with `tonbo machine sleep <machine>`, then run the command again.",
   volume_holder_changed: "The Volume is not on the Machine you named; nothing was changed. `tonbo volume show <volume>` says which Machine has it: name that one, or use `tonbo volume move`.",
   volume_image_mismatch: "The Volume is a Machine's whole disk, made against one image; it moves only to a Machine on that same image. Nothing was changed.",
-  volume_rebuild_pending: "The Volume's Rebuild has not finished; move it once it has. Nothing was changed.",
+  volume_rebuild_pending: "The Volume's Rebuild is recorded and applies at its Machine's next wake: wake that Machine once (`tonbo machine wake <machine>`), then move the Volume. Nothing was changed.",
   secret_env_conflict: "Use another secret key or remove the non-secret env variable with that name.",
   secret_limit: "Reduce the number or byte size of this Machine's secrets.",
   wake_unavailable: "The wake was refused for now; nothing woke. Wake it again after a while; `tonbo machine show` says why it is blocked."
@@ -5902,7 +6160,8 @@ var MACHINE_WAKE_BLOCKED_HINTS = {
   capacity: "No host had room for its shape: Tonbo is adding a host, <minutes>, and the next request after that wakes it.",
   region_closed: "Machines are closed in its region for now; the next request after they reopen wakes it.",
   budget_slowdown: "Its budget is close to running out, and this wake would pass the budget's slow-down rate: sleep another Machine of the budget, or lower this one's shape, then wake it again. Machines already awake keep running.",
-  budget_exhausted: "Its budget is used up for the month: it wakes after the budget resets, or once a person raises it in the console."
+  budget_exhausted: "Its budget is used up for the month: it wakes after the budget resets, or once a person raises it in the console.",
+  root_image_mismatch: "Its disk was made over another image than the Machine's: run `tonbo machine rebuild <name>` to move the disk to the Machine's image (Rebuild deletes changes outside /home, /workspace and /root)."
 };
 var MACHINE_ACCOUNT_EGRESS_BLOCKED_HINT = "If this is the free egress cap: 10 GiB a month without purchased credit; buy credit at <billing> to lift it.";
 function minutesUntil(retryAt, now = Date.now()) {
@@ -5975,7 +6234,7 @@ function imageFailureFields(machine) {
     ...next ? [["Next step", next]] : []
   ];
 }
-function machineFields(machine, billing, etag = null, lastEnd = null) {
+function machineFields(machine, billing, etag = null, lastEnd = null, volumeName2 = null) {
   return fields([
     ["Name", machine.name],
     ["ID", machine.id],
@@ -5998,7 +6257,7 @@ function machineFields(machine, billing, etag = null, lastEnd = null) {
     ["SSH", `${machine.hostnames.ssh} (tonbo ssh ${machine.name})`],
     ["Env", Object.keys(machine.env).sort().join(", ") || "none"],
     ["Stop grace", `${machine.stop_grace_seconds} s`],
-    ["Volume", volumeText(machine)],
+    ["Volume", volumeText(machine, volumeName2)],
     ...deleteFields(machine),
     ["Database", machine.database ? `${machine.database.name} (${machine.database.url})` : "none"],
     ["Logs", machine.logs.url],
@@ -6043,13 +6302,28 @@ function deleteFields(machine) {
     ]
   ];
 }
-function volumeText(machine) {
+function volumeText(machine, name = null) {
   const binding = machine.volumes?.[0];
   if (!binding) return "none";
-  return binding.path === void 0 ? `${binding.volume} (whole disk)` : `${binding.volume} at ${binding.path}`;
+  if (name === null)
+    return binding.path === void 0 ? `${binding.volume} (whole disk)` : `${binding.volume} at ${binding.path}`;
+  return binding.path === void 0 ? `${name} (whole disk; id ${binding.volume})` : `${name} at ${binding.path} (id ${binding.volume})`;
+}
+async function volumeName(deps, key, machine) {
+  const id = machine.volumes?.[0]?.volume;
+  if (id === void 0) return null;
+  try {
+    return (await deps.api.listVolumes(key)).data.find((volume) => volume.id === id)?.name ?? null;
+  } catch (error) {
+    if (!(error instanceof HttpError || error instanceof AccessTokenError)) throw error;
+    return null;
+  }
 }
-function machineText(machine, billing, etag = null, lastEnd = null) {
-  return [machineFields(machine, billing, etag, lastEnd), ...privatePortLines(machine)].join("\n");
+function machineText(machine, billing, etag = null, lastEnd = null, volume = null) {
+  return [
+    machineFields(machine, billing, etag, lastEnd, volume),
+    ...privatePortLines(machine)
+  ].join("\n");
 }
 function keyStateText(machine) {
   const state = machine.byoc.key_state;
@@ -6074,8 +6348,8 @@ function deviceFields(machine) {
     ["Updated", machine.updated_at]
   ]);
 }
-function anyMachineText(machine, billing, etag = null, lastEnd = null) {
-  return machine.kind === "byoc" ? deviceFields(machine) : machineText(machine, billing, etag, lastEnd);
+function anyMachineText(machine, billing, etag = null, lastEnd = null, volume = null) {
+  return machine.kind === "byoc" ? deviceFields(machine) : machineText(machine, billing, etag, lastEnd, volume);
 }
 function parsePorts(specs) {
   const accesses = machinePortAccess;
@@ -6444,11 +6718,15 @@ async function machineShowCommand(deps, name, options = {}) {
       ...processes.running.map((line) => `Background process: ${line}`),
       ...processes.last ? [`Last background process: ${processes.last}`] : []
     ] : [];
+    const volume = options.json || machine.kind === "byoc" ? null : await volumeName(deps, key, machine);
     print(
       deps,
       options.json,
       machine,
-      [anyMachineText(machine, await billingUrl(deps), etag, lastEnd), ...processLines].join("\n")
+      [
+        anyMachineText(machine, await billingUrl(deps), etag, lastEnd, volume),
+        ...processLines
+      ].join("\n")
     );
   });
 }
@@ -6532,6 +6810,8 @@ function appliesText(name, change) {
 }
 async function machineUpdateCommand(deps, name, command, options = {}) {
   await machineCommand(async () => {
+    if (options.rebuild && options.image === void 0)
+      throw new Error("--rebuild needs --image: it moves the Machine's whole disk to that image.");
     if (command.length && options.imageCommand)
       throw new Error("Give a command or --image-command, not both.");
     if (options.clearPorts && (options.port?.length || options.defaultPort !== void 0))
@@ -6576,7 +6856,27 @@ async function machineUpdateCommand(deps, name, command, options = {}) {
     if (options.discardSnapshot) change.discard_snapshot = true;
     if (Object.values(change).every((value) => value === void 0))
       throw new Error("Nothing to change: pass at least one option or a command.");
-    const machine = await deps.api.updateMachine(key, name, etag, change);
+    const rebuild = () => rebuildUntilDone(
+      deps,
+      key,
+      name,
+      DEFAULT_WAIT_SECONDS,
+      () => deps.api.updateMachineRebuild(key, name, etag, change)
+    );
+    let rebuilt = options.rebuild ? await rebuild() : null;
+    let machine = rebuilt?.machine;
+    if (!machine)
+      try {
+        machine = await deps.api.updateMachine(key, name, etag, change);
+      } catch (error) {
+        if (!(error instanceof HttpError && error.code === "rebuild_required" && deps.interactive()))
+          throw error;
+        const question = `${rebuildWarning(options.image ?? current.image.reference)}
+This Machine's Volume is its whole disk, so its image changes only by Rebuild. Type the Machine's name to rebuild it with this change:`;
+        if (await deps.ask(question) !== name) throw new Error("Cancelled; nothing was changed.");
+        rebuilt = await rebuild();
+        machine = rebuilt.machine;
+      }
     specWarnings(deps, machine.ports, Object.keys(setEnv));
     print(
       deps,
@@ -6584,12 +6884,80 @@ async function machineUpdateCommand(deps, name, command, options = {}) {
       machine,
       [
         `Updated Machine ${machine.name} to revision ${machine.revision}.`,
-        ...appliesText(machine.name, change),
+        ...rebuilt ? [rebuiltText(machine.name, rebuilt.rebuild)] : appliesText(machine.name, change),
         machineText(machine, await billingUrl(deps))
       ].join("\n")
     );
   });
 }
+function rebuildWarning(image) {
+  return machineRebuildWarning.map((paragraph) => paragraph.replaceAll("**", "").replaceAll("<image>", image)).join("\n");
+}
+function rebuiltText(name, answer) {
+  const { reference, digest } = answer.image;
+  const image = digest === null ? reference : `${reference} (${digest})`;
+  if (answer.state === "not_needed")
+    return `Machine ${name}'s disk was never used, so it moves to ${image} with no Rebuild.`;
+  return `Machine ${name} rebuilds onto ${image} at its next wake; files in /home, /workspace and /root are kept.`;
+}
+async function rebuildUntilDone(deps, key, name, timeout, send) {
+  const now = deps.now ?? Date.now;
+  const start = now();
+  for (; ; ) {
+    const answer = await send();
+    if (answer.rebuild.state !== "waiting_for_sleep") return answer;
+    deps.notice(
+      `Machine ${name} is awake with its disk attached, so it is going to sleep first; the Rebuild is sent again once it is asleep.`
+    );
+    const { machine: asleep } = await waitForMachine(
+      deps,
+      key,
+      name,
+      answer.retryAfterSeconds ?? sleepPollAfterSeconds,
+      sleepPollAfterSeconds,
+      timeout - (now() - start) / 1e3,
+      (read) => read.status.power === "asleep" || read.state !== "active"
+    );
+    if (!asleep)
+      throw new Error(
+        `Machine ${name} is not asleep after ${Math.round((now() - start) / 1e3)} s, so nothing was rebuilt; run the command again once it sleeps. \`tonbo machine show ${name}\` says what keeps it awake.`
+      );
+    if (asleep.status.power !== "asleep")
+      throw new Error(`Machine ${name} is ${asleep.state}; nothing was rebuilt.`);
+  }
+}
+async function machineRebuildCommand(deps, name, options = {}) {
+  await machineCommand(async () => {
+    const key = await deps.auth.apiKey();
+    const { machine: read, etag } = await deps.api.getMachineWithEtag(key, name);
+    if (read.kind === "byoc")
+      throw new Error(
+        `${name} is one of your computers; only \`tonbo machine show\` and \`tonbo machine delete\` serve it.`
+      );
+    const image = options.image ?? read.image.reference;
+    await confirm(
+      deps,
+      options.yes,
+      `rebuild Machine ${name}`,
+      () => Promise.resolve(`${rebuildWarning(image)}
+Type the Machine's name to rebuild it:`),
+      name
+    );
+    const answer = await rebuildUntilDone(
+      deps,
+      key,
+      name,
+      options.timeout ?? DEFAULT_WAIT_SECONDS,
+      () => deps.api.rebuildMachine(key, name, { image: options.image }, etag ?? void 0)
+    );
+    print(
+      deps,
+      options.json,
+      { data: answer.machine, rebuild: answer.rebuild },
+      rebuiltText(name, answer.rebuild)
+    );
+  });
+}
 function sleptText(machine) {
   if (machine.state === "creating")
     return `Machine ${machine.name} is still creating; nothing to put to sleep.`;
@@ -6672,43 +7040,61 @@ async function machineWakeCommand(deps, name, options = {}) {
 }
 async function machineDeleteCommand(deps, name, options = {}) {
   await machineCommand(async () => {
+    if (options.keepVolume && options.deleteVolume)
+      throw new Error("Give --keep-volume or --delete-volume, not both.");
+    const deleteVolume = options.deleteVolume ? true : options.keepVolume ? false : void 0;
     const key = await deps.auth.apiKey();
     const read = { etag: null };
     await confirm(
       deps,
       options.yes,
       `delete Machine ${name}`,
-      () => deleteQuestion(deps, key, name, read),
+      () => deleteQuestion(deps, key, name, read, deleteVolume),
       name
     );
-    const { machine, kind } = await deps.api.deleteMachine(
+    const { machine, kind, volume } = await deps.api.deleteMachine(
       key,
       name,
-      ifMatchHeader(options.ifMatch) ?? read.etag ?? void 0
+      ifMatchHeader(options.ifMatch) ?? read.etag ?? void 0,
+      deleteVolume
+    );
+    print(
+      deps,
+      options.json,
+      machine,
+      [deletedText(name, machine, kind), ...volume ? [volumeFateText(volume)] : []].join("\n")
     );
-    print(deps, options.json, machine, deletedText(name, machine, kind));
     if (machine?.kind === "byoc" && machine.byoc.key_state === "active")
       deps.notice(
         `Its key is still active, so ${name} registers again at its next start. Run \`yield logout\` on it, or revoke its key with \`tonbo api-key revoke\`, then forget it again.`
       );
   });
 }
-async function deleteQuestion(deps, key, name, read) {
-  let kind = null;
-  let ownDatabase = false;
+async function deleteQuestion(deps, key, name, read, deleteVolume) {
+  let machine = null;
   try {
     const answer = await deps.api.getMachineWithEtag(key, name);
-    kind = answer.machine.kind;
-    ownDatabase = answer.machine.kind === "managed" && !!answer.machine.database?.name.startsWith("m.");
+    machine = answer.machine;
     read.etag = answer.etag;
   } catch (error) {
     if (!(error instanceof HttpError && error.status === 404)) throw error;
   }
-  if (kind === "byoc")
+  if (machine?.kind === "byoc")
     return `Forget your computer ${name}? It disappears from your Machines; its key is not revoked. Type its name to confirm:`;
-  if (kind === "managed")
-    return `Delete Machine ${name} with its disk${ownDatabase ? ", database" : ""} and logs? This cannot be undone. Type the Machine's name to confirm:`;
-  return `Delete Machine ${name}? Type its name to confirm:`;
+  if (machine?.kind !== "managed") return `Delete Machine ${name}? Type its name to confirm:`;
+  const ownDatabase = !!machine.database?.name.startsWith("m.");
+  const binding = machine.volumes?.[0];
+  const parts = [
+    ...binding && binding.path === void 0 ? [] : ["disk"],
+    ...ownDatabase ? ["database"] : []
+  ];
+  const what = parts.length ? `${parts.join(", ")} and logs` : "logs";
+  const volume = binding ? `Volume ${await volumeName(deps, key, machine) ?? binding.volume}` : "";
+  const fate = !binding ? "" : deleteVolume === true ? ` Its ${volume} is deleted with it.` : deleteVolume === false ? ` Its ${volume} is kept.` : ` Its ${volume} is deleted with it if it was made for this Machine (as the console makes a new Machine's disk), and kept otherwise; --keep-volume or --delete-volume decides.`;
+  return `Delete Machine ${name} with its ${what}?${fate} This cannot be undone. Type the Machine's name to confirm:`;
+}
+function volumeFateText(volume) {
+  return volume.deleted ? `Volume ${volume.name}: deleted with it.` : `Volume ${volume.name}: kept; delete it with \`tonbo volume delete ${volume.name}\`.`;
 }
 function deletedText(name, machine, kind) {
   if (kind === "byoc")
@@ -6838,7 +7224,7 @@ var TOPICS = [
     id: "confirmations",
     title: "Destructive commands",
     text: [
-      "`api-key revoke`, `bucket delete`, `database delete`, `stream delete`, `machine delete` and `volume delete` ask before they act when stdin and stderr are a terminal: a revocation is confirmed by typing `yes`, a deletion by typing the resource's name, as in the console. Without a terminal they refuse unless `--yes` is given."
+      "`api-key revoke`, `bucket delete`, `database delete`, `stream delete`, `machine delete`, `machine rebuild` and `volume delete` ask before they act when stdin and stderr are a terminal: a revocation is confirmed by typing `yes`, a deletion or a Rebuild by typing the resource's name, as in the console. Without a terminal they refuse unless `--yes` is given."
     ]
   }
 ];
@@ -7077,6 +7463,18 @@ var COMMAND_HELP = {
     arguments: NAME("database"),
     defaults: ACTIVITY_DEFAULTS
   },
+  "tonbo database metrics": {
+    about: [
+      "Prints the database's metrics, one row per UTC hour or day: its stored size at the step's end (the log and snapshots it keeps), the write units, bytes and records written, the successful reads and live (long-poll or SSE) reads and the bytes they streamed, and the median and 99th percentile server latency of its appends and catch-up reads. Server latency is measured at Tonbo's servers, from request to response headers; your network adds to this. A dash is a value not measured (a size before the meter's first sample, a latency with no request); the current step is still growing.",
+      "Give `--window`, or `--from` and `--to` with `--granularity` (at most 31 days hourly, 92 days daily; server latency is kept 8 days hourly). `--series` prints only the series it names. It carries no money: `tonbo database usage` says what it cost."
+    ],
+    examples: [
+      "tonbo database metrics notes --window 7d",
+      "tonbo database metrics notes --series server_write_latency_p50_ms,server_write_latency_p99_ms"
+    ],
+    arguments: NAME("database"),
+    defaults: { "--window": "24h" }
+  },
   "tonbo database usage": {
     about: [
       "Prints each database's usage of one calendar month in UTC at list price, before the monthly allowance and credit: its write units, log and snapshot GiB-months and list value, then the account's other metered usage (its streams and everything else). The charges after allowance and credit are in `tonbo usage show`."
@@ -7135,6 +7533,18 @@ var COMMAND_HELP = {
     arguments: NAME("stream"),
     defaults: ACTIVITY_DEFAULTS
   },
+  "tonbo stream metrics": {
+    about: [
+      "Prints the stream's metrics, one row per UTC hour or day: its stored size at the step's end (the log and snapshots it keeps), the write units, bytes and records written, the successful reads and live (long-poll or SSE) reads and the bytes they streamed, and the median and 99th percentile server latency of its appends and catch-up reads. Server latency is measured at Tonbo's servers, from request to response headers; your network adds to this. A dash is a value not measured (a size before the meter's first sample, a latency with no request); the current step is still growing.",
+      "Give `--window`, or `--from` and `--to` with `--granularity` (at most 31 days hourly, 92 days daily; server latency is kept 8 days hourly). `--series` prints only the series it names. It carries no money: `tonbo stream usage` says what it cost."
+    ],
+    examples: [
+      "tonbo stream metrics events --window 7d",
+      "tonbo stream metrics events --series server_write_latency_p50_ms,server_write_latency_p99_ms"
+    ],
+    arguments: NAME("stream"),
+    defaults: { "--window": "24h" }
+  },
   "tonbo stream usage": {
     about: [
       "Prints each stream's usage of one calendar month in UTC at list price, before the monthly allowance and credit, then the account's other metered usage (its databases and everything else). The charges after allowance and credit are in `tonbo usage show`."
@@ -7176,7 +7586,7 @@ var COMMAND_HELP = {
   },
   "tonbo machine show": {
     about: [
-      "Prints the Machine's state and what it means (an `active` Machine that is asleep boots on its first request), its hostnames, image and whether it is pulled, the live activation and conditions with what to do about each, when it sleeps, the database it binds (or none) and its logs URL, a link to what its disk keeps, its ETag and who created it. For an `active` Machine it also reads the newest activations and prints how the last one ended. When the live activation runs an older revision than the Machine's, it says which changes already apply and that the rest apply after `tonbo machine sleep <name>`.",
+      "Prints the Machine's state and what it means (an `active` Machine that is asleep boots on its first request), its hostnames, image and whether it is pulled, the live activation and conditions with what to do about each, when it sleeps, the database it binds (or none), its Volume by name and id as its whole disk or where it is mounted (or none), its logs URL, a link to what its disk keeps, its ETag and who created it. For an `active` Machine it also reads the newest activations and prints how the last one ended. When the live activation runs an older revision than the Machine's, it says which changes already apply and that the rest apply after `tonbo machine sleep <name>`.",
       "When the default port is private, it prints the `curl` call that reaches it with a personal key. For one of your computers it prints its system, harnesses, hostname and device id, which only you see."
     ],
     examples: ["tonbo machine show web"],
@@ -7207,10 +7617,13 @@ var COMMAND_HELP = {
   "tonbo machine update": {
     about: [
       "Changes only what its options name. It reads the Machine and sends the ETag it read, or `--if-match`'s, so a change someone made in between is refused with `precondition_failed` rather than overwritten; a Machine whose creation failed is refused with `machine_failed`. `--env` and `--unset-env` change single variables; `--port` replaces every port, and the current default port stays the default while it is still listed.",
-      "Ports and `--sleep-after` apply at once. The image, command, shape, env, Volume and database apply at the next boot, and the command says how to apply them now: `tonbo machine sleep`, after which the next request boots the new spec. Naming the same tag again resolves its digest again. A Machine whose Volume is its whole disk keeps its image: another image is refused with `rebuild_required`, since only Rebuild, which keeps /home, /workspace and /root and deletes every other change on the disk, may move it, and Rebuild is not available yet. `--database <name>` binds another database of the account in the Machine's region, which no other Machine binds, and `--no-database` binds none; the database it leaves is kept. A Machine created with its own database keeps it.",
+      "Ports and `--sleep-after` apply at once. The image, command, shape, env, Volume and database apply at the next boot, and the command says how to apply them now: `tonbo machine sleep`, after which the next request boots the new spec. Naming the same tag again resolves its digest again. A Machine whose Volume is its whole disk keeps its image: another image is refused with `rebuild_required`, since only Rebuild, which keeps /home, /workspace and /root and deletes every other change on the disk, may move it. At a terminal the CLI then prints what Rebuild deletes and, once you type the Machine's name, sends the change again as a Rebuild; `--rebuild` with `--image` sends it as one at once, as `tonbo machine rebuild` does, and on a Machine whose Volume is mounted at a path, or that has none, it is refused with `volume_not_whole_disk`. `--database <name>` binds another database of the account in the Machine's region, which no other Machine binds, and `--no-database` binds none; the database it leaves is kept. A Machine created with its own database keeps it.",
       "`--delete-after` applies at once and keeps the clock, which counts from the end of the Machine's last activation (or its creation), so a lower value can delete a Machine that has already slept that long; `--no-delete-after` turns it off. `tonbo machine show` prints when it will be deleted."
     ],
-    examples: ["tonbo machine update web --env MODE=staging --sleep-after 300"],
+    examples: [
+      "tonbo machine update web --env MODE=staging --sleep-after 300",
+      "tonbo machine update agent --image ghcr.io/acme/agent:v2 --rebuild"
+    ],
     arguments: {
       name: "the Machine's name",
       command: "the command that replaces the Machine's command at the next boot, after `--`"
@@ -7346,9 +7759,25 @@ var COMMAND_HELP = {
     arguments: NAME("Machine"),
     defaults: { "--timeout": String(DEFAULT_WAIT_SECONDS) }
   },
+  "tonbo machine rebuild": {
+    about: [
+      "Moves a Machine whose Volume is its whole disk to an image: `--image`, or without it the Machine's own reference resolved again, so a newer build of its tag is taken. Rebuild keeps /home, /workspace and /root and deletes every other change on the disk. At a terminal it prints the warning of what it deletes and asks you to type the Machine's name first, and sends the ETag it read then.",
+      "An asleep Machine answers at once: the Rebuild is recorded and the disk moves to the image at the next wake, or, when the disk was never used, the image changes with no Rebuild. An awake Machine with its disk attached is put to sleep first and nothing else changes; the CLI reads it until it is asleep, for up to `--timeout`, and sends the Rebuild again. A Machine whose Volume is mounted at a path, or that has none, is refused with `volume_not_whole_disk`: change its image with `tonbo machine update --image`."
+    ],
+    examples: [
+      "tonbo machine rebuild agent --image ghcr.io/acme/agent:v2",
+      "tonbo machine rebuild agent --yes"
+    ],
+    arguments: NAME("Machine"),
+    defaults: {
+      "--image": "the Machine's own image reference, resolved again",
+      "--timeout": String(DEFAULT_WAIT_SECONDS)
+    },
+    json: "answer"
+  },
   "tonbo machine delete": {
     about: [
-      "Deletes the Machine with its disk and logs; a Volume or database it binds stays. Its name is free for a new Machine at once. At a terminal it asks you to type the Machine's name first, and sends the ETag it read then.",
+      "Deletes the Machine with its disk and logs; a database it binds stays. The Volume it holds is deleted with it when it was made for it, as the console makes a new Machine's disk, and kept otherwise; `--delete-volume` deletes any Volume it holds and `--keep-volume` keeps it. The command then says which. Its name is free for a new Machine at once. At a terminal it asks you to type the Machine's name first, and sends the ETag it read then.",
       "For one of your computers it forgets the computer: it leaves the list at once, and its name is free once the forget completes. Forgetting does not revoke the computer's key, so a computer whose key is still active registers again at its next start; run `yield logout` on it, or `tonbo api-key revoke`, first."
     ],
     examples: ["tonbo machine delete web --yes"],
@@ -7476,6 +7905,22 @@ var COMMAND_HELP = {
     examples: ["tonbo metrics machines --window 30d"],
     defaults: { "--window": "7d" }
   },
+  "tonbo metrics databases": {
+    about: [
+      "Prints the account's databases per UTC hour or day, summed over every region, with the same series as `tonbo database metrics`: the total's server latency comes from every database's merged histograms, never an average of percentiles. Server latency is measured at Tonbo's servers, from request to response headers; your network adds to this. Then each database's row over the window: its stored size at the last measured step and its counts summed.",
+      "Give `--window`, or `--from` and `--to` with `--granularity` (at most 31 days hourly, 92 days daily)."
+    ],
+    examples: ["tonbo metrics databases --window 30d --series stored_bytes,write_units"],
+    defaults: { "--window": "7d" }
+  },
+  "tonbo metrics streams": {
+    about: [
+      "Prints the account's streams per UTC hour or day, summed over every region, with the same series as `tonbo stream metrics`: the total's server latency comes from every stream's merged histograms, never an average of percentiles. Server latency is measured at Tonbo's servers, from request to response headers; your network adds to this. Then each stream's row over the window: its stored size at the last measured step and its counts summed.",
+      "Give `--window`, or `--from` and `--to` with `--granularity` (at most 31 days hourly, 92 days daily)."
+    ],
+    examples: ["tonbo metrics streams --window 30d --series stored_bytes,write_units"],
+    defaults: { "--window": "7d" }
+  },
   "tonbo metrics volumes": {
     about: [
       "Prints what the account's Volumes stored, one line per UTC day of the window: the average bytes their files held that day, compressed, summed over every region, which is what they are billed for. Today, and a day not fully rated yet, is marked `so far`. Then the change between the window's first and last complete days.",
@@ -9118,6 +9563,15 @@ function createProgram(makeDependencies = createDependencies) {
   ).action(
     async (name, options) => databaseActivityCommand(dependencies(), name, options)
   );
+  operationOptions(
+    database.command("metrics <name>").description("show a database's writes, reads, stored size and server latency over time").option("--window <window>", "24h or 7d hourly, 30d or 90d daily; 24h when omitted").option(
+      "--series <series>",
+      "the series to print, comma-separated; every series when omitted"
+    ).option("--granularity <step>", "with --from and --to, hour or day").option("--from <time>", "with --to, the window's start, on a UTC hour or day").option("--to <time>", "with --from, the window's end, exclusive"),
+    "getDatabaseMetrics"
+  ).action(
+    async (name, options) => databaseMetricsCommand(dependencies(), name, options)
+  );
   operationOptions(
     database.command("usage").description("each database's usage of one month at list price, before allowance and credit").option("--period <month>", "the calendar month in UTC, as YYYY-MM").option("--sort <order>", "list_value (highest first) or name", parseUsageSort).option("--prefix <prefix>", "only databases whose name starts with this").option("--names <names>", "only these databases, up to 100 names, comma-separated"),
     "listDatabaseUsage"
@@ -9179,6 +9633,15 @@ function createProgram(makeDependencies = createDependencies) {
   ).action(
     async (name, options) => streamActivityCommand(dependencies(), name, options)
   );
+  operationOptions(
+    stream.command("metrics <name>").description("show a stream's writes, reads, stored size and server latency over time").option("--window <window>", "24h or 7d hourly, 30d or 90d daily; 24h when omitted").option(
+      "--series <series>",
+      "the series to print, comma-separated; every series when omitted"
+    ).option("--granularity <step>", "with --from and --to, hour or day").option("--from <time>", "with --to, the window's start, on a UTC hour or day").option("--to <time>", "with --from, the window's end, exclusive"),
+    "getStreamMetrics"
+  ).action(
+    async (name, options) => streamMetricsCommand(dependencies(), name, options)
+  );
   operationOptions(
     stream.command("usage").description("each stream's usage of one month at list price, before allowance and credit").option("--period <month>", "the calendar month in UTC, as YYYY-MM").option("--sort <order>", "list_value (highest first) or name", parseUsageSort).option("--prefix <prefix>", "only streams whose name starts with this").option("--names <names>", "only these streams, up to 100 names, comma-separated"),
     "listStreamUsage"
@@ -9252,7 +9715,10 @@ function createProgram(makeDependencies = createDependencies) {
     machineSpecOptions(
       machine.command("update <name> [command...]").description(
         "change a Machine; [command...] after -- replaces its command at the next boot"
-      ).option("--image <reference>", "a new image, named as for create; applies at the next boot").option("--image-command", "run the image's own CMD again at the next boot").option("--unset-env <KEY>", "remove an environment variable; repeat for several", repeated).option("--clear-ports", "remove every port").option("--if-match <etag>", ifMatchHelp("change")).option("--discard-snapshot", "apply a change that discards the Machine's snapshot").option("--no-volume", "remove the Machine's Volume at the next boot; the Volume is kept").option(
+      ).option("--image <reference>", "a new image, named as for create; applies at the next boot").option("--image-command", "run the image's own CMD again at the next boot").option(
+        "--rebuild",
+        "with --image, move a Machine whose Volume is its whole disk to the image by Rebuild, which deletes changes outside /home, /workspace and /root"
+      ).option("--unset-env <KEY>", "remove an environment variable; repeat for several", repeated).option("--clear-ports", "remove every port").option("--if-match <etag>", ifMatchHelp("change")).option("--discard-snapshot", "apply a change that discards the Machine's snapshot").option("--no-volume", "remove the Machine's Volume at the next boot; the Volume is kept").option(
         "--database <name>",
         "bind the account's database <name> of the Machine's region instead; applies at the next wake"
       ).option("--no-database", "bind no database from the next wake; the database is kept").option("--no-delete-after", "never delete the Machine for being asleep"),
@@ -9378,7 +9844,19 @@ function createProgram(makeDependencies = createDependencies) {
     async (name, options) => machineWakeCommand(dependencies(), name, options)
   );
   operationOptions(
-    machine.command("delete <name>").description("delete a Machine with its disk and logs, or forget one of your computers").option("--yes", "delete without asking; required when stdin is not a terminal").option("--if-match <etag>", ifMatchHelp("delete")),
+    machine.command("rebuild <name>").description(
+      "move a Machine whose Volume is its whole disk to an image; deletes changes outside /home, /workspace and /root"
+    ).option("--image <reference>", "the image to move to, named as for create").option("--yes", "rebuild without asking; required when stdin is not a terminal").option(
+      "--timeout <seconds>",
+      "how long to wait for an awake Machine to sleep, in seconds",
+      parseWhole
+    ),
+    "rebuildMachine"
+  ).action(
+    async (name, options) => machineRebuildCommand(dependencies(), name, options)
+  );
+  operationOptions(
+    machine.command("delete <name>").description("delete a Machine with its disk and logs, or forget one of your computers").option("--yes", "delete without asking; required when stdin is not a terminal").option("--if-match <etag>", ifMatchHelp("delete")).option("--keep-volume", "keep the Machine's Volume, even one made for it").option("--delete-volume", "delete the Machine's Volume with it, even one not made for it"),
     "deleteMachine"
   ).action(
     async (name, options) => machineDeleteCommand(dependencies(), name, options)
@@ -9472,6 +9950,24 @@ function createProgram(makeDependencies = createDependencies) {
     ).option("--granularity <step>", "with --from and --to, hour or day").option("--from <time>", "with --to, the window's start, on a UTC hour or day").option("--to <time>", "with --from, the window's end, exclusive"),
     "getAccountMachineMetrics"
   ).action(async (options) => metricsMachinesCommand(dependencies(), options));
+  operationOptions(
+    metrics.command("databases").description(
+      "show the account's databases' writes, reads, stored size and server latency over time"
+    ).option("--window <window>", "24h or 7d hourly, 30d or 90d daily; 7d when omitted").option(
+      "--series <series>",
+      "the series to print, comma-separated; every series when omitted"
+    ).option("--granularity <step>", "with --from and --to, hour or day").option("--from <time>", "with --to, the window's start, on a UTC hour or day").option("--to <time>", "with --from, the window's end, exclusive"),
+    "getAccountDatabaseMetrics"
+  ).action(async (options) => metricsDatabasesCommand(dependencies(), options));
+  operationOptions(
+    metrics.command("streams").description(
+      "show the account's streams' writes, reads, stored size and server latency over time"
+    ).option("--window <window>", "24h or 7d hourly, 30d or 90d daily; 7d when omitted").option(
+      "--series <series>",
+      "the series to print, comma-separated; every series when omitted"
+    ).option("--granularity <step>", "with --from and --to, hour or day").option("--from <time>", "with --to, the window's start, on a UTC hour or day").option("--to <time>", "with --from, the window's end, exclusive"),
+    "getAccountStreamMetrics"
+  ).action(async (options) => metricsStreamsCommand(dependencies(), options));
   const ssh = program.command("ssh").description("open a terminal on a Machine, or run a command there, over SSH").argument("<machine>", "the Machine's name").argument("[command...]", "a command to run instead of a shell, after --").action(async (name, command) => sshCommand(dependencies(), name, command));
   ssh.command("config").description(
     "print the ssh_config block that lets ssh, scp, sftp and Remote-SSH reach every Machine"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tonbo/cli",
-  "version": "0.22.0",
+  "version": "0.24.0",
   "description": "The Tonbo CLI. Compute, disks, databases and streams for AI agents: your agent picks what it needs, sets it up, and knows what it costs, from the command line.",
   "homepage": "https://tonbo.dev",
   "bugs": {