insta 0.0.30 → 0.0.32

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,7 +116,7 @@ export function parseCpu(raw) {
         throw new Error(`invalid cpu: ${raw} (provider sizes: ${CPU_SIZES.join(', ')})`);
     return n;
 }
-// ---- volume (the persistent /data disk; attach any time, grow-only, never detach) ----
+// ---- 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) {
@@ -126,7 +126,7 @@ export function volumeLines(name, volume, cap) {
         ];
     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)',
     ];
 }
 // Render the PUT result. Pure, exported for tests. `attached` comes from the backend and is what
@@ -138,16 +138,56 @@ export function volumeWriteLine(name, body) {
     }
     return `compute ${name}: volume grown to ${body.volume.sizeGib}Gi at ${body.volume.mountPath}  (plan max ${body.cap.volumeGib}Gi)`;
 }
-// Show, attach, or grow a compute service's /data volume. No --size: a safe read (size + mount
-// path + the plan cap). --size: PUT .../volume — attaches when no volume exists, grows otherwise.
-// 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).
+// 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)

package/dist/commands/db.js

@@ -4,8 +4,9 @@ import { parseVolumeGib } from './services.js';
 // Toggle a postgres service between scale-to-zero (the default: instance suspends when idle,
 // cold-starts on the next connection) and always-on (instance stays warm; idle RAM bills at
 // actual usage). Thin wrapper over PATCH /database/settings {scaleToZero} — insta-db-backed
-// postgres only; Neon-backed services manage their own autosuspend and the platform returns an
-// error for them.
+// postgres only. Legacy Neon path: Neon is no longer used by any environment (postgres is 100%
+// insta-db) and this code is retained, not live — Neon-backed services managed their own
+// autosuspend and the platform returned an error for them.
 export async function dbAlwaysOn(mode, opts) {
     if (mode !== 'on' && mode !== 'off')
         throw new Error('mode must be on|off');
@@ -53,7 +54,8 @@ export async function fetchDbInstance(api, projectId, suffix) {
     }
     catch (e) {
         // The platform answers a provider-shaped 502 for services with no manageable instance
-        // (Neon-backed): a soft case, not a failure. Everything else stays an error — an expired
+        // (the legacy Neon path — Neon is no longer used by any environment; this branch is retained,
+        // not live): a soft case, not a failure. Everything else stays an error — an expired
         // token must not render as "no ceiling set" — but wrapped so the user sees what failed.
         if (e instanceof ApiError && e.status === 502)
             return { kind: 'no-instance' };
@@ -78,7 +80,7 @@ export async function dbLimits(opts) {
     if (!opts.cpu && !opts.memory) {
         const read = await fetchDbInstance(api, p.projectId, suffix);
         if (read.kind === 'no-instance') {
-            info(`postgres ${opts.group ?? 'default'}: no manageable instance (Neon-backed services manage their own resources)`);
+            info(`postgres ${opts.group ?? 'default'}: no manageable instance (this service manages its own resources)`);
             return;
         }
         if (opts.json)
@@ -161,9 +163,11 @@ export function dbStatsLines(group, body) {
 }
 // Point-in-time stats snapshot for a postgres service: connections vs the server's ceiling, cache
 // hit rate, database size. Read-only. insta-db-backed: a suspended instance answers from the
-// provider's control plane (shown as "(suspended)" with structural zeros), never dialed.
-// Neon-backed: the platform reads over a direct SQL connection, so a one-shot call may wake a
-// suspended endpoint — acceptable for an explicit command, which is why nothing here polls.
+// provider's control plane (shown as "(suspended)" with structural zeros), never dialed. That is
+// every environment today — the Neon-backed contrast below is historical: Neon is no longer used
+// anywhere, and the code that handled it is retained, not live. Neon-backed: the platform read
+// over a direct SQL connection, so a one-shot call could wake a suspended endpoint — acceptable
+// for an explicit command, which is why nothing here polls.
 export async function dbStats(opts) {
     const api = await ApiClient.load();
     const p = await requireProject();
@@ -207,7 +211,7 @@ export async function dbVolume(opts) {
     if (!opts.size) {
         const read = await fetchDbInstance(api, p.projectId, suffix);
         if (read.kind === 'no-instance') {
-            info(`postgres ${opts.group ?? 'default'}: no manageable instance (Neon-backed services manage their own storage)`);
+            info(`postgres ${opts.group ?? 'default'}: no manageable instance (this service manages its own storage)`);
             return;
         }
         if (opts.json)

package/dist/commands/metrics.js

@@ -97,7 +97,9 @@ function printDimensions(dims) {
 }
 // insta usage — usage across the 5 billing dimensions (cpu/memory/volume/egress/storage) for the
 // current billing cycle. Shows the whole ORG by default (with a per-project breakdown); pass --proj
-// [id] for a single project (the linked one, or a given id). Billed dimensions, not raw fly/neon meters.
+// [id] for a single project (the linked one, or a given id). Billed dimensions, not raw provider
+// meters. (Historical: those were fly/neon meters — Neon is no longer used by any environment,
+// though the adapter code is retained, not live.)
 export async function usage(opts) {
     const api = await ApiClient.load();
     const p = await requireProject();

package/dist/commands/services.js

@@ -23,6 +23,16 @@ export function parseCount(raw) {
         throw new Error(`count must be a positive integer, got: ${raw}`);
     return n;
 }
+// Parse a TCP port. Junk fails here rather than reaching the API as NaN (the parseCpu lesson).
+// Decimal digits only, as parseVolumeGib: `Number()` alone would quietly read 0x1f90 as 8080 and
+// 1e3 as 1000, and a port written in hex is a typo worth reporting, not one worth honouring.
+export function parsePort(raw) {
+    const m = /^\s*(\d+)\s*$/.exec(raw);
+    const n = m ? Number(m[1]) : NaN;
+    if (!Number.isInteger(n) || n < 1 || n > 65535)
+        throw new Error(`port must be an integer between 1 and 65535, got: ${raw}`);
+    return n;
+}
 // Parse a volume size in whole Gi: "10" or "10Gi" (suffix case-insensitive — unlike the db
 // quantity strings this is not a provider pass-through; the wire value is an integer). Volumes
 // are provisioned block disks, so fractional and Mi values are rejected locally with an example
@@ -64,7 +74,7 @@ export function resolveComputeServiceId(services, name) {
 export function servicesAddRequestBody(type, name, branch, opts) {
     return {
         type, name, ...(branch ? { branch } : {}), public: !!opts.public,
-        ...(opts.image ? { image: opts.image } : {}), ...(opts.port ? { port: Number(opts.port) } : {}),
+        ...(opts.image ? { image: opts.image } : {}), ...(opts.port ? { port: parsePort(opts.port) } : {}),
         ...(opts.region ? { region: opts.region } : {}),
         ...(opts.alwaysOn ? { alwaysOn: true } : {}),
         ...(opts.volume !== undefined ? { volumeGib: parseVolumeGib(opts.volume) } : {}),
@@ -78,8 +88,11 @@ export async function servicesAdd(type, name, opts = {}) {
         throw new Error('--region is not valid for storage services');
     if (opts.image && type !== 'compute')
         throw new Error('--image is only valid for compute services');
-    if (opts.port && type !== 'compute')
-        throw new Error('--port is only valid for compute services');
+    if (opts.port) {
+        if (type !== 'compute')
+            throw new Error('--port is only valid for compute services');
+        parsePort(opts.port); // junk fails here, before any config/network access
+    }
     if (opts.alwaysOn && type !== 'compute')
         throw new Error('--always-on is only valid for compute services (for postgres, use `insta db always-on on` after creation)');
     if (opts.volume !== undefined) {
@@ -93,6 +106,8 @@ export async function servicesAdd(type, name, opts = {}) {
     const res = await api.rawRequest('POST', `/projects/${p.projectId}/services`, servicesAddRequestBody(type, name, branch, opts));
     if (handleApproval(res))
         return;
+    if (opts.json)
+        return printJson(res.body.service);
     const svc = res.body.service;
     const access = svc.type === 'storage' ? `  [${svc.public ? 'public' : 'private'}]` : '';
     const img = svc.image ? `  running ${svc.image}${svc.port ? `:${svc.port}` : ''}` : '';

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

@@ -13,6 +13,7 @@ import * as org from './commands/org.js';
 import * as project from './commands/project.js';
 import * as branch from './commands/branch.js';
 import * as services from './commands/services.js';
+import { resolveServiceArgs, serviceArgsDeps } from './resolve-service.js';
 import * as regions from './commands/regions.js';
 import * as secretsCmd from './commands/secrets.js';
 import { deploy } from './commands/deploy.js';
@@ -108,7 +109,10 @@ br.command('merge <source>').description('Merge a branch service set into anothe
     .option('--into <branch>', 'target branch (default: current)').action(guard((source, o) => branch.branchMerge(source, o)));
 // ---- services (opt-in postgres/storage/compute) ----
 const svc = program.command('services').alias('svc').description('Manage project services (postgres|storage|compute)');
-svc.command('add <type> <name>').description('Provision a service on demand (assigns a default domain for postgres/compute)')
+// [type] [name] are optional so the command can answer "what can I add?" — a terminal is walked
+// through the dashboard's Add Service kinds, anything else gets that list back as an error
+// (resolve-service.ts). Picking Docker Image also fills in --image/--port from the answers.
+svc.command('add [type] [name]').description('Provision a service on demand (assigns a default domain for postgres/compute); with no type/name, a terminal picks from the service kinds')
     .option('--branch <branch>', 'target branch (default: current)')
     .option('--region <region>', 'region for postgres/compute, e.g. us-east (see `insta regions`)')
     .option('--public', 'storage only: serve the bucket with anonymous public-read (default private)')
@@ -116,7 +120,11 @@ svc.command('add <type> <name>').description('Provision a service on demand (ass
     .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 (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)));
+    .option('--json')
+    .action(guard(async (type, name, o) => {
+    const a = await resolveServiceArgs(type, name, serviceArgsDeps(o.json), o);
+    return services.servicesAdd(a.type, a.name, { ...o, image: a.image ?? o.image, port: a.port ?? o.port });
+}));
 svc.command('list').option('--json').option('--branch <branch>', 'branch (default: current)')
     .action(guard((o) => services.servicesList(o)));
 svc.command('remove <type> <name>').description('Remove a service and destroy its resources')
@@ -129,7 +137,7 @@ svc.command('set-access <type> <name> <access>').description('Set a storage serv
     .option('--json').action(guard((type, name, access, o) => services.servicesSetAccess(type, name, access, o)));
 svc.command('scale <type> <name> <number> [region]').description('Set a compute service machine count (paid plans only)')
     .option('--json').option('--branch <branch>', 'branch (default: current)').action(guard((type, name, number, region, o) => services.servicesScale(type, name, number, region, o)));
-svc.command('upgrade <type> <name> <spec>').description('Change a compute/postgres service spec (paid plans only)')
+svc.command('upgrade <type> <name> <spec>').description('Change a compute service spec (paid plans only). Postgres upgrades are rejected by the platform — use `insta db limits` instead')
     .option('--json').option('--branch <branch>', 'branch (default: current)').action(guard((type, name, spec, o) => services.servicesUpgrade(type, name, spec, o)));
 svc.command('secrets <type> <name>').description("List a service's secret names")
     .option('--branch <b>').option('--json').action(guard((type, name, o) => services.servicesSecrets(type, name, o)));
@@ -171,8 +179,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, attach, or grow a compute service's persistent /data volume. No --size: 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). 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/dist/resolve-service.js

@@ -0,0 +1,161 @@
+// `insta services add` with no type (or no name): the kinds are otherwise only discoverable by
+// guessing wrong and reading `type must be postgres|storage|compute`, so missing arguments answer
+// "what can I add?" instead. The list mirrors the dashboard's Add Service menu (frontend
+// `add-service-button.tsx`) — Docker Image sits BESIDE Empty Service, not under it, because
+// picking an image is a different intent rather than a compute flag. An agent gets the same list
+// as an error, because nothing was created and a silent exit 0 would read as success.
+import * as clack from '@clack/prompts';
+import { SERVICE_TYPES, assertServiceName, parsePort } from './commands/services.js';
+// Same order, labels and default names as the dashboard's Add Service menu. Github Repo is left
+// out: the platform has no repo path yet, so a CLI entry could only say "coming soon".
+export const SERVICE_KINDS = [
+    { id: 'image', label: 'Docker Image', type: 'compute', hint: 'run an existing container image', needsImage: true },
+    { id: 'postgres', label: 'Postgres', type: 'postgres', hint: 'relational DB, usable as soon as it is added', defaultName: 'main-db' },
+    { id: 'storage', label: 'Storage', type: 'storage', hint: 'S3-compatible bucket, private by default', defaultName: 'assets' },
+    { id: 'compute', label: 'Empty Service', type: 'compute', hint: 'an app to deploy code to (empty until `insta deploy`)', defaultName: 'compute' },
+];
+// The platform's own default; the dialog prefills the same number.
+export const DEFAULT_IMAGE_PORT = '8080';
+/** Registry refs aren't URLs — quietly strip a pasted scheme prefix (mirrors the dashboard). */
+export function normalizeImageRef(raw) {
+    return raw.trim().replace(/^https?:\/\//, '');
+}
+/**
+ * Name from an image ref: last path segment, sans tag/digest, kebab-safe (the dashboard's rule).
+ * Also capped at the 39 chars `assertServiceName` allows — a suggestion the user cannot accept
+ * unchanged is worse than none.
+ */
+export function suggestServiceName(ref) {
+    const last = ref.split('@')[0].split('/').pop() ?? '';
+    return last
+        .split(':')[0]
+        .toLowerCase()
+        .replace(/[^a-z0-9-]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 39)
+        .replace(/-+$/g, '');
+}
+/** The non-interactive command for a kind — what an agent should run instead of being asked. */
+export function kindCommand(k) {
+    if (k.needsImage)
+        return `insta services add compute <name> --image <ref> --port <n>`;
+    return `insta services add ${k.type} ${k.defaultName}`;
+}
+/** The kind list, one line each — what a terminal picks from and an agent reads. */
+export function serviceKindLines() {
+    return SERVICE_KINDS.map((k) => `  ${k.label.padEnd(14)} ${kindCommand(k)}`);
+}
+/** What to say when there is no terminal to ask: the missing half, and how to supply it. */
+export function missingArgsMessage(type) {
+    // A bare type names the plain kind, never Docker Image — that one is reached with --image.
+    const known = SERVICE_KINDS.find((k) => k.type === type && !k.needsImage);
+    if (known)
+        return `name the service:  ${kindCommand(known)}`;
+    return ['what to add:', ...serviceKindLines()].join('\n');
+}
+/**
+ * Fill in whatever `insta services add` was not given. An unknown type passes straight through so
+ * `assertType` — not this — reports it, keeping one wording for a bad type everywhere. Flags that
+ * were already supplied are never asked for again.
+ */
+export async function resolveServiceArgs(type, name, deps, given = {}) {
+    if (type && name)
+        return { type, name };
+    if (type && !SERVICE_TYPES.includes(type))
+        return { type, name: name ?? '' };
+    if (!deps.tty)
+        throw new Error(missingArgsMessage(type));
+    // A bad --port is a typo in the command, not an answer: fail before asking anything.
+    if (given.port !== undefined)
+        parsePort(given.port);
+    const kind = type
+        ? SERVICE_KINDS.find((k) => k.type === type && !k.needsImage)
+        : await deps.selectKind(SERVICE_KINDS);
+    if (!kind)
+        return { type: type, name: name ?? '' };
+    if (!kind.needsImage) {
+        return { type: kind.type, name: name ?? (await deps.askName(kind, kind.defaultName ?? '')) };
+    }
+    // The prompt validates a typed ref; a --image that normalizes away would slip past it and
+    // provision a plain empty compute instead (servicesAddRequestBody drops a falsy image).
+    const image = normalizeImageRef(given.image ?? (await deps.askImage()));
+    if (!image)
+        throw new Error('an image reference is required');
+    return {
+        type: kind.type,
+        name: name ?? (await deps.askName(kind, suggestServiceName(image))),
+        image,
+        port: given.port ?? (await deps.askPort(DEFAULT_IMAGE_PORT)),
+    };
+}
+/** Real prompts (clack, as the InsForge CLI's `create`); cancelling exits without provisioning. */
+export async function promptServiceKind(kinds) {
+    const picked = await clack.select({
+        message: 'What do you want to add?',
+        options: kinds.map((k) => ({ value: k.id, label: k.label, hint: k.hint })),
+    });
+    if (clack.isCancel(picked))
+        process.exit(0);
+    // Resolve against the list that was displayed — a subset must not fall through to the registry.
+    return kinds.find((k) => k.id === picked);
+}
+export async function promptImageRef() {
+    const answer = await clack.text({
+        message: 'Image reference:',
+        placeholder: 'nginx:latest',
+        validate: (v) => (normalizeImageRef(v) ? undefined : 'an image reference is required'),
+    });
+    if (clack.isCancel(answer))
+        process.exit(0);
+    return answer;
+}
+export async function promptServiceName(kind, suggested) {
+    const answer = await clack.text({
+        message: `Name this ${kind.type} service:`,
+        initialValue: suggested,
+        // The same rule the command enforces, reported before Enter rather than after a round trip.
+        validate: (v) => {
+            try {
+                assertServiceName(v.trim());
+                return undefined;
+            }
+            catch (e) {
+                return e.message;
+            }
+        },
+    });
+    if (clack.isCancel(answer))
+        process.exit(0);
+    return answer.trim();
+}
+export async function promptPort(fallback) {
+    const answer = await clack.text({
+        message: 'Port the image listens on:',
+        initialValue: fallback,
+        // The rule the command enforces, so the prompt and a --port can never disagree.
+        validate: (v) => {
+            try {
+                parsePort(v.trim());
+                return undefined;
+            }
+            catch (e) {
+                return e.message;
+            }
+        },
+    });
+    if (clack.isCancel(answer))
+        process.exit(0);
+    return answer.trim();
+}
+/** Prompts on a real terminal only — an agent's stdin is not one, and must never block. */
+export function serviceArgsDeps(json) {
+    return {
+        selectKind: promptServiceKind,
+        askImage: promptImageRef,
+        askName: promptServiceName,
+        askPort: promptPort,
+        // --json asked for parseable output, so a caller that happens to own a TTY still gets the error.
+        tty: !json && !!process.stdin.isTTY && !!process.stdout.isTTY,
+    };
+}
+//# sourceMappingURL=resolve-service.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "insta",
-  "version": "0.0.30",
+  "version": "0.0.32",
   "type": "module",
   "description": "InstaCloud CLI — a thin client of the platform control-plane API.",
   "keywords": [
@@ -42,6 +42,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
+    "@clack/prompts": "^0.9.1",
     "commander": "^12.1.0"
   },
   "devDependencies": {