insta 0.0.29 → 0.0.31

package/dist/commands/compute.js

@@ -1,4 +1,4 @@
-import { ApiClient, requireProject } from '../api.js';
+import { ApiClient, ApiError, requireProject } from '../api.js';
 import { info, printJson, handleApproval } from '../util.js';
 import { resolveComputeServiceId, q, parseVolumeGib } from './services.js';
 // Attach a developer-owned custom domain to a branch's compute service. Fly issues the cert + routes
@@ -116,29 +116,78 @@ export function parseCpu(raw) {
         throw new Error(`invalid cpu: ${raw} (provider sizes: ${CPU_SIZES.join(', ')})`);
     return n;
 }
-// ---- volume (the persistent /data disk; attach is create-time only) ----
+// ---- volume (the persistent /data disk; attach any time, grow-only, deletable; never detach) ----
 // Render the volume read. Pure, exported for tests (mirrors serviceListLine). Every plan may view;
 // only growth is paid — that gate is the backend's to enforce, so nothing here pre-blocks.
 export function volumeLines(name, volume, cap) {
     if (!volume)
         return [
-            `compute ${name}: no volume attached (attach is create-time only: \`insta services add compute <name> --volume <gi>\`)`,
+            `compute ${name}: no volume attached (attach one: \`insta compute volume ${name} --size <gi>\` — it mounts at /data on the next deploy)`,
         ];
     return [
         `compute ${name}: volume ${volume.sizeGib}Gi at ${volume.mountPath}  (plan max ${cap.volumeGib}Gi)`,
-        '  billing is actual data stored — the size is a cap, not a price; grow with --size (grow-only)',
+        '  billing is actual data stored — the size is a cap, not a price; grow with --size (grow-only), delete with --delete (destroys the data)',
     ];
 }
-// Show or grow a compute service's /data volume. No --size: a safe read (size + mount path + the
-// plan cap). --size: grow via PUT .../volume — paid and grow-only, but both gates belong to the
-// backend, whose 403/400 messages carry the upgrade hints and must reach the user verbatim (the
-// guard prints ApiError messages as-is).
+// Render the PUT result. Pure, exported for tests. `attached` comes from the backend and is what
+// tells a FIRST attach (no disk yet — it mounts on the next deploy) apart from a grow (the live
+// disk was already extended); the wire size is authoritative in both cases.
+export function volumeWriteLine(name, body) {
+    if (body.attached) {
+        return `compute ${name}: volume ${body.volume.sizeGib}Gi attached — mounts at ${body.volume.mountPath} on the next deploy  (plan max ${body.cap.volumeGib}Gi)`;
+    }
+    return `compute ${name}: volume grown to ${body.volume.sizeGib}Gi at ${body.volume.mountPath}  (plan max ${body.cap.volumeGib}Gi)`;
+}
+// Render the DELETE result. Pure, exported for tests. Deleting is the only way off the volume
+// path (there is no detach), so the line says what came back with it: the two constraints the
+// volume imposed.
+export function volumeDeleteLine(name) {
+    return `compute ${name}: volume deleted — the disk and its data are gone; suspend fast-wake and scale-out are back`;
+}
+// Map a DELETE .../volume failure. Pure, exported for tests (r2d2 review rounds 1+2: this is the
+// close-call branch worth pinning). An older backend has no DELETE route, and what its 404 looks
+// like depends on who answered: the real platform (Fastify, no custom notFound handler) sends its
+// default body {"message":"Route DELETE:/… not found","error":"Not Found"} → ApiError message
+// "Not Found"; a proxy or bodyless 404 leaves ApiError's own "HTTP 404" fallback. BOTH are the
+// generic route-miss shape and mean version skew, not a bug — parroting them would send the user
+// hunting the wrong thing. A backend that HAS the route names the real problem in a DOMAIN
+// message ("this service has no volume", …), which must flow verbatim, 404 or not.
+const GENERIC_404 = /^(HTTP 404|Not Found)$/i;
+export function volumeDeleteError(e) {
+    if (e instanceof ApiError && e.status === 404 && GENERIC_404.test(e.message.trim())) {
+        return new Error('this backend does not support volume delete yet — update the platform, or delete the service to remove its volume');
+    }
+    return e;
+}
+// Show, attach, grow, or delete a compute service's /data volume. No flag: a safe read (size +
+// mount path + the plan cap). --size: PUT .../volume — attaches when no volume exists, grows
+// otherwise. --delete: DELETE .../volume — destroys the disk and its data immediately (no detach,
+// no undo; billing stops now). The paid/cap/machine-count gates all belong to the backend, whose
+// 403/400 messages carry the upgrade hints and must reach the user verbatim (the guard prints
+// ApiError messages as-is).
 export async function computeVolume(serviceName, opts) {
+    if (opts.delete && opts.size)
+        throw new Error('--delete cannot be combined with --size (one changes the volume, the other destroys it)');
     const api = await ApiClient.load();
     const p = await requireProject();
     const branch = opts.branch ?? p.branch;
     const { services } = await api.request('GET', `/projects/${p.projectId}/services${q(branch)}`);
     const id = resolveComputeServiceId(services, serviceName);
+    if (opts.delete) {
+        let res;
+        try {
+            res = await api.rawRequest('DELETE', `/projects/${p.projectId}/services/${id}/volume`);
+        }
+        catch (e) {
+            throw volumeDeleteError(e);
+        }
+        if (handleApproval(res))
+            return;
+        if (opts.json)
+            return printJson(res.body);
+        info(volumeDeleteLine(res.body.service?.name ?? serviceName ?? id));
+        return;
+    }
     if (!opts.size) {
         const r = await api.request('GET', `/projects/${p.projectId}/services/${id}/volume`);
         if (opts.json)
@@ -153,8 +202,7 @@ export async function computeVolume(serviceName, opts) {
         return;
     if (opts.json)
         return printJson(res.body);
-    const v = res.body.volume;
-    info(`compute ${res.body.service?.name ?? serviceName ?? id}: volume grown to ${v.sizeGib}Gi at ${v.mountPath}  (plan max ${res.body.cap.volumeGib}Gi)`);
+    info(volumeWriteLine(res.body.service?.name ?? serviceName ?? id, res.body));
 }
 // Show or set a compute service's ceiling. With no --memory it PRINTS the current limits and the
 // plan cap (so `insta compute limits` is a safe read), which is also what a UI renders as a slider

package/dist/flyctl-build.js

@@ -72,6 +72,24 @@ export async function ensureFlyctl() {
             info((await ok('brew', ['install', 'flyctl'], true)) ? 'flyctl installed ✓' : 'flyctl install failed — install manually: https://fly.io/docs/flyctl/install/');
             return;
         }
+        if (process.platform === 'linux') {
+            // A fresh Linux machine (CI containers included — insta-e2e run 31284364163) has no flyctl
+            // and no brew; without this branch `insta deploy <dir>` dead-ends on a hand-install of a
+            // third-party CLI. Official installer, pinned into ~/.fly; the current process extends its
+            // own PATH because the installer's shell-profile edit can't reach an already-running process.
+            info('flyctl not found — installing to ~/.fly (one-time)…');
+            const flyHome = `${process.env.HOME ?? '~'}/.fly`;
+            const installed = await ok('sh', ['-c', `curl -fsSL https://fly.io/install.sh | FLYCTL_INSTALL="${flyHome}" sh`], true);
+            if (installed) {
+                process.env.PATH = `${process.env.PATH}:${flyHome}/bin`;
+                if (await ok('flyctl', ['version'])) {
+                    info('flyctl installed ✓');
+                    return;
+                }
+            }
+            info('flyctl install failed — install manually: https://fly.io/docs/flyctl/install/');
+            return;
+        }
         info('flyctl (fly CLI) not found — install it to deploy from source: https://fly.io/docs/flyctl/install/');
     }
     catch { /* best-effort convenience */ }

package/dist/index.js

@@ -115,7 +115,7 @@ svc.command('add <type> <name>').description('Provision a service on demand (ass
     .option('--image <url>', 'compute only: run this container image at creation')
     .option('--port <n>', 'compute only: port the image listens on (default 8080)')
     .option('--always-on', 'compute only: create as always-on — never scales to zero (all plans; billing is actual usage either way)')
-    .option('--volume <gi>', 'compute only: attach a persistent /data volume of this many whole Gi (create-time only; any plan may attach at the default 1; larger sizes are paid and plan-capped). Volume services keep 1 machine and stop (cold wake) instead of suspend when idle')
+    .option('--volume <gi>', 'compute only: attach a persistent /data volume of this many whole Gi (also attachable later: `insta compute volume <name> --size <gi>`; any plan may attach at the default 1; larger sizes are paid and plan-capped). Volume services keep 1 machine and stop (cold wake) instead of suspend when idle')
     .action(guard((type, name, o) => services.servicesAdd(type, name, o)));
 svc.command('list').option('--json').option('--branch <branch>', 'branch (default: current)')
     .action(guard((o) => services.servicesList(o)));
@@ -171,8 +171,9 @@ compute.command('limits [service]').description("Show or set a compute service's
     .option('--json').option('--branch <branch>', 'branch (default: current)').action(guard((service, o) => computeCmd.computeLimits(service, o)));
 compute.command('always-on <mode> [service]').description('Set a compute service always-on (mode: on|off). on = machines never scale to zero; off = default scale-to-zero. All plans; billing is actual usage either way')
     .option('--json').option('--branch <branch>', 'branch (default: current)').action(guard((mode, service, o) => computeCmd.computeAlwaysOn(mode, service, o)));
-compute.command('volume [service]').description("Show or grow a compute service's persistent /data volume. No --size: print size, mount path, and the plan cap (any plan). --size grows it (paid plans; grow-only — a provisioned disk cannot shrink). Attach is create-time only: `insta services add compute <name> --volume <gi>`. Billing is actual data stored — the size is a cap, not a price")
+compute.command('volume [service]').description("Show, attach, grow, or delete a compute service's persistent /data volume. No flag: print size, mount path, and the plan cap (any plan). --size on a volumeless service ATTACHES one (any plan at the default 1Gi; larger is paid and plan-capped; the disk mounts at /data on the next deploy); on a volume-bearing one it grows (paid plans; grow-only — a provisioned disk cannot shrink). --delete DESTROYS the disk and ALL its data immediately (no detach, no undo; billing stops now, and suspend fast-wake + scale-out return). Billing is actual data stored — the size is a cap, not a price")
     .option('--size <gi>', 'new size in whole Gi, e.g. 10 (must be ≥ the current size)')
+    .option('--delete', 'destroy the volume and ALL its data (irreversible; download anything you need first)')
     .option('--json').option('--branch <branch>', 'branch (default: current)').action(guard((service, o) => computeCmd.computeVolume(service, o)));
 // ---- db (postgres service controls) ----
 const db = program.command('db').description('Postgres service controls (limits / volume / always-on / scale-to-zero)');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "insta",
-  "version": "0.0.29",
+  "version": "0.0.31",
   "type": "module",
   "description": "InstaCloud CLI — a thin client of the platform control-plane API.",
   "keywords": [