insta 0.0.52 → 0.0.54

package/README.md

@@ -233,6 +233,7 @@ build never reaches a production installer.
 | `INSTA_PROJECT_ID` · `INSTA_ORG_ID` · `INSTA_BRANCH` | Target a project, org or branch without linking |
 | `INSTA_PASSWORD` | Password for non-interactive login |
 | `INSTA_NO_AUTOUPDATE` | Disable self-update |
+| `INSTA_NO_TELEMETRY` · `DO_NOT_TRACK` | Disable usage analytics. Each command sends one event (command, flags, outcome, version, OS) to the same PostHog project as the console. Only ids, enums and numbers among the arguments are kept — names, branches, keys, paths, secret values, free text and error messages never leave the machine; custom API hosts report nothing |
 
 ## Agent skills
 

package/dist/commands/compute.js

@@ -1,5 +1,5 @@
 import { ApiClient, ApiError, requireProject } from '../api.js';
-import { info, printJson, handleApproval } from '../util.js';
+import { info, printJson, handleApproval, relayExitCode } from '../util.js';
 import { resolveComputeServiceId, q, parseVolumeGib } from './services.js';
 export const isWorker = (s) => s.port === 0;
 // One line per compute service for the disambiguation error: name, region, default URL, status —
@@ -543,10 +543,10 @@ export function applyExecResult(res, json) {
     // visible. Normal codes pass through untouched.
     if (exitCode < 0 || exitCode > 255) {
         process.stderr.write(`note: remote exit code ${exitCode} out of range — exiting 1\n`);
-        process.exitCode = 1;
+        relayExitCode(1);
     }
     else {
-        process.exitCode = exitCode;
+        relayExitCode(exitCode);
     }
 }
 // One HTTP round trip, not a shell session: no PTY, no interactivity, stdout/stderr come back as

package/dist/commands/db.js

@@ -1,7 +1,7 @@
 import { spawn } from 'node:child_process';
 import { constants as osConstants } from 'node:os';
 import { ApiClient, ApiError, requireProject } from '../api.js';
-import { info, printJson, handleApproval } from '../util.js';
+import { info, printJson, handleApproval, relayExitCode } from '../util.js';
 import { parseVolumeGib, q, resolveSoleService } 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
@@ -330,6 +330,6 @@ export async function dbConnect(opts) {
         return;
     // stderr: stdout belongs to psql (the `insta run` rule).
     process.stderr.write(`psql → postgres/${r.serviceName}${branch ? ` (branch ${branch})` : ''} — a suspended instance wakes on connect, so the first prompt can take a few seconds\n`);
-    process.exit(await connectWithPsql(r.url));
+    relayExitCode(await connectWithPsql(r.url));
 }
 //# sourceMappingURL=db.js.map

package/dist/commands/deploy.js

@@ -1,7 +1,7 @@
 import { resolve, join } from 'node:path';
 import { existsSync, readFileSync } from 'node:fs';
 import { ApiClient, ApiError, requireProject } from '../api.js';
-import { info, die, printJson, handleApproval, renderNextActions } from '../util.js';
+import { info, die, printJson, handleApproval, renderNextActions, CliExit } from '../util.js';
 import { flyctlBuildAndPush, ensureFlyctl, defaultBuildRunner, stderrBuildRunner } from '../flyctl-build.js';
 // With --json, stdout must carry exactly one JSON document (the deploy result), so every progress
 // line moves to stderr.
@@ -116,9 +116,8 @@ export async function buildFromSource(api, projectId, dir, branch, opts, run = o
         log(`  built ${built}`);
         return built;
     }
-    // exit() with no argument honors the exit code handleApproval just set (2).
     if (handleApproval(tok, opts.json))
-        process.exit();
+        throw new CliExit();
     const { token, flyApp } = tok.body;
     await ensureFlyctl(); // cloud path only — the local path needs docker, which the daemon requires anyway
     const port = opts.port ? Number(opts.port) : 8080;

package/dist/commands/feedback.js

@@ -12,7 +12,7 @@ import os from 'node:os';
 import * as clack from '@clack/prompts';
 import { readGlobal, readProject } from '../config.js';
 import { envForApiUrl } from '../env.js';
-import { info, printJson } from '../util.js';
+import { info, printJson, CliCancel } from '../util.js';
 import { clean } from '../redact.js';
 export const TYPES = ['bug', 'feature-request', 'friction', 'other'];
 export const COMPONENTS = ['cli', 'mcp', 'platform', 'skills', 'docs', 'other'];
@@ -73,7 +73,7 @@ async function promptMissing(opts) {
             ],
         });
         if (clack.isCancel(answer))
-            process.exit(0);
+            throw new CliCancel();
         opts.type = answer;
     }
     if (!opts.component) {
@@ -82,7 +82,7 @@ async function promptMissing(opts) {
             options: COMPONENTS.map((c) => ({ value: c, label: c })),
         });
         if (clack.isCancel(answer))
-            process.exit(0);
+            throw new CliCancel();
         opts.component = answer;
     }
     if (!opts.title) {
@@ -91,7 +91,7 @@ async function promptMissing(opts) {
             validate: (v) => (v.trim() ? undefined : 'required'),
         });
         if (clack.isCancel(answer))
-            process.exit(0);
+            throw new CliCancel();
         opts.title = answer.trim();
     }
     if (!opts.detail && !opts.file) {
@@ -100,7 +100,7 @@ async function promptMissing(opts) {
             validate: (v) => (v.trim() ? undefined : 'required'),
         });
         if (clack.isCancel(answer))
-            process.exit(0);
+            throw new CliCancel();
         opts.detail = answer.trim();
     }
 }

package/dist/commands/run.js

@@ -4,7 +4,7 @@
 // as the process does.
 import { spawn } from 'node:child_process';
 import { ApiClient, requireProject } from '../api.js';
-import { die, handleApproval } from '../util.js';
+import { CliExit, die, handleApproval, relayExitCode } from '../util.js';
 /** Core, dependency-injected for tests: spawn cmd with the bundle in env, return its exit code. */
 export async function runWithSecrets(cmd, args, deps) {
     const bundle = await deps.fetchBundle();
@@ -28,15 +28,14 @@ export async function run(cmdAndArgs, opts) {
     const code = await runWithSecrets(cmd, rest, {
         fetchBundle: async () => {
             const res = await api.rawRequest('GET', `/projects/${p.projectId}/secrets?branch=${encodeURIComponent(branch)}`);
-            // exit() with no argument honors the exit code handleApproval just set (2).
             if (handleApproval(res))
-                process.exit();
+                throw new CliExit();
             // stderr, not stdout: `insta run`'s stdout belongs entirely to the child command (that's why
             // run has no --json — wrapping would break the child's own output contract).
             process.stderr.write(`running with ${Object.keys(res.body.secrets).length} injected secrets (branch ${branch}) — nothing written to disk\n`);
             return res.body.secrets;
         },
     });
-    process.exit(code);
+    relayExitCode(code);
 }
 //# sourceMappingURL=run.js.map

package/dist/commands/template.js

@@ -7,7 +7,7 @@ import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import * as clack from '@clack/prompts';
 import { ApiClient, ApiError, requireProject } from '../api.js';
-import { info, printJson, handleApproval, renderNextActions } from '../util.js';
+import { info, printJson, handleApproval, renderNextActions, CliCancel } from '../util.js';
 import { MANIFEST_FILE, collectManifestVariables, loadTemplateManifest } from '../template-manifest.js';
 // One aligned row per template; numeric columns right-aligned. Plain padded columns, as the rest
 // of the CLI (storage list, compute check-domain) — no table library.
@@ -26,12 +26,15 @@ export function templateListLines(templates) {
 }
 // The info endpoint may list services as an array or keep the manifest's map shape — render both.
 export function normalizeInfoServices(raw) {
-    if (Array.isArray(raw)) {
-        return raw.map((s) => ({ name: s.name ?? '?', type: s.type, port: s.port, volumeGib: s.volumeGib ?? s.volume?.size }));
-    }
-    if (raw && typeof raw === 'object') {
-        return Object.entries(raw).map(([name, s]) => ({ name, type: s?.type, port: s?.port, volumeGib: s?.volumeGib ?? s?.volume?.size }));
-    }
+    const one = (name, s) => ({
+        name, type: s?.type, port: s?.port,
+        volumeGib: s?.volumeGib ?? s?.volume?.size,
+        volume: s?.volume === true || s?.volumeGib != null || s?.volume?.size != null,
+    });
+    if (Array.isArray(raw))
+        return raw.map((s) => one(s?.name ?? '?', s));
+    if (raw && typeof raw === 'object')
+        return Object.entries(raw).map(([name, s]) => one(name, s));
     return [];
 }
 // Variables may arrive as one array with a `required` flag, or pre-grouped {required, optional}
@@ -64,7 +67,10 @@ export function templateInfoLines(t, bold = (s) => s) {
     const services = normalizeInfoServices(t.services);
     if (services.length) {
         const summary = services.map((s) => {
-            const bits = [s.type && s.type !== 'compute' ? s.type : undefined, s.port ? `port ${s.port}` : undefined, s.volumeGib ? `${s.volumeGib}Gi volume` : undefined].filter(Boolean);
+            // A size only when the registry still carries one: a manifest names no size any more, so
+            // "persistent /data" is all there is to say until the service exists.
+            const disk = s.volumeGib ? `${s.volumeGib}Gi volume` : s.volume ? 'persistent /data' : undefined;
+            const bits = [s.type && s.type !== 'compute' ? s.type : undefined, s.port ? `port ${s.port}` : undefined, disk].filter(Boolean);
             return `${s.name}${bits.length ? ` (${bits.join(', ')})` : ''}`;
         });
         lines.push(`services (${services.length}): ${summary.join(', ')}`);
@@ -290,7 +296,7 @@ async function promptVariable(v) {
         validate: (s) => (s.trim() ? undefined : 'required'),
     });
     if (clack.isCancel(answer))
-        process.exit(0);
+        throw new CliCancel();
     return answer.trim();
 }
 export async function templateDeploy(target, opts = {}, deps = {}) {

package/dist/index.js

@@ -2,7 +2,8 @@
 import { readFileSync } from 'node:fs';
 import { Command } from 'commander';
 import { ApiError } from './api.js';
-import { CliExit, fail } from './util.js';
+import { CliCancel, CliExit, fail, relayedExitCode } from './util.js';
+import { trackCommand } from './telemetry.js';
 import * as auth from './commands/auth.js';
 import * as envCmd_ from './commands/env.js';
 import { ENV_NAMES } from './env.js';
@@ -31,14 +32,28 @@ import { billing, billingUpgrade, billingPortal } from './commands/billing.js';
 import * as selfUpdate from './commands/upgrade.js';
 import * as feedbackCmd from './commands/feedback.js';
 function onError(e) {
-    if (e instanceof CliExit)
+    if (e instanceof CliExit || e instanceof CliCancel)
         return;
     if (e instanceof ApiError)
         return fail(`${e.message} (HTTP ${e.status})`);
     fail(e instanceof Error ? e.message : String(e));
 }
 // Wrap an async action so rejections surface as clean CLI errors.
-const guard = (fn) => (...a) => fn(...a).then(() => undefined).catch(onError);
+// commander appends (options, command) to every action's arguments, so the command is always last.
+const guard = (fn) => async (...a) => {
+    const started = Date.now();
+    let error;
+    try {
+        await fn(...a);
+    }
+    catch (e) {
+        error = e;
+        onError(e);
+    }
+    await trackCommand(a[a.length - 1], a.slice(0, -2), {
+        error, durationMs: Date.now() - started, exitCode: Number(process.exitCode ?? 0), childExitCode: relayedExitCode(),
+    }, resolveVersion());
+};
 const program = new Command();
 // Positional options: some command groups (e.g. `secrets`, `billing`) declare a flag (like
 // --branch or --org) both on the group itself (for its own default action) and on a subcommand

package/dist/resolve-service.js

@@ -6,6 +6,7 @@
 // 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';
+import { CliCancel } from './util.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 = [
@@ -98,7 +99,7 @@ export async function promptServiceKind(kinds) {
         options: kinds.map((k) => ({ value: k.id, label: k.label, hint: k.hint })),
     });
     if (clack.isCancel(picked))
-        process.exit(0);
+        throw new CliCancel();
     // Resolve against the list that was displayed — a subset must not fall through to the registry.
     return kinds.find((k) => k.id === picked);
 }
@@ -109,7 +110,7 @@ export async function promptImageRef() {
         validate: (v) => (normalizeImageRef(v) ? undefined : 'an image reference is required'),
     });
     if (clack.isCancel(answer))
-        process.exit(0);
+        throw new CliCancel();
     return answer;
 }
 export async function promptServiceName(kind, suggested) {
@@ -128,7 +129,7 @@ export async function promptServiceName(kind, suggested) {
         },
     });
     if (clack.isCancel(answer))
-        process.exit(0);
+        throw new CliCancel();
     return answer.trim();
 }
 export async function promptPort(fallback) {
@@ -147,7 +148,7 @@ export async function promptPort(fallback) {
         },
     });
     if (clack.isCancel(answer))
-        process.exit(0);
+        throw new CliCancel();
     return answer.trim();
 }
 /** Prompts on a real terminal only — an agent's stdin is not one, and must never block. */

package/dist/telemetry.js

@@ -0,0 +1,217 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import { dirname, join } from 'node:path';
+import { ApiError } from './api.js';
+import { readGlobal, readProject } from './config.js';
+import { ENVS, envForApiUrl, isEnvName, normalizeUrl } from './env.js';
+import { COMPONENTS, SEVERITIES, TYPES } from './commands/feedback.js';
+import { SERVICE_TYPES } from './commands/services.js';
+import { detectChannel } from './commands/upgrade.js';
+import { CliCancel, CliExit } from './util.js';
+export const POSTHOG_HOST = 'https://us.i.posthog.com';
+// The console's project keys (insta-frontend src/lib/analytics.ts), so a CLI event lands on the
+// person the console identified. Write-only capture tokens: safe to ship in a public binary.
+const PROJECT_KEYS = {
+    prod: 'phc_yHWfNfkDuQpJ34yKQ4equid3j64zj3tBRtpej3b5i8QH',
+    staging: 'phc_BeXdaHFfeaCJFAH26TyEi3LB9xwHj23U6LdfKWP46G4U',
+};
+// The send is awaited before the process exits, so it gets one bounded attempt and no retry.
+const SEND_TIMEOUT_MS = 1500;
+const REDACTED = '[REDACTED]';
+const oneOf = (values) => (v) => values.includes(v);
+const ID = (v) => /^(?:[0-9a-f]{8}-[0-9a-f-]{27}|[a-z]+_[\w-]{1,64}|(?=.*\d)[\w-]{1,64})$/i.test(v);
+const SLUG = (v) => /^[a-z0-9][a-z0-9-]{0,63}$/.test(v);
+const NUMBER = (v) => /^\d+(?:\.\d+)?[a-z]{0,3}$/i.test(v);
+const REGION = (v) => /^[a-z]{2,3}(?:-[a-z0-9]+)+$/.test(v);
+const SERVICE = oneOf(SERVICE_TYPES);
+// `login`/`env use` accept the name case-insensitively; so does this.
+const ENV = (v) => isEnvName(v.trim().toLowerCase());
+const ON_OFF = oneOf(['on', 'off']);
+const TARGET = oneOf(['db', 'compute', 'redis', 'mysql', 'mongodb']);
+const POLICY_ACTION = (v) => /^(?:secrets|deploy|project|branch|service|storage)(?:\.[a-zA-Z]+)?$/.test(v);
+const SAFE_ARGS = {
+    'env use': { 0: ENV }, 'project link': { 0: ID },
+    'services add': { 0: SERVICE }, 'services remove': { 0: SERVICE }, 'services rename': { 0: SERVICE }, 'services secrets': { 0: SERVICE },
+    'services set-access': { 0: SERVICE, 2: oneOf(['public', 'private']) },
+    'services scale': { 0: SERVICE, 2: NUMBER, 3: REGION }, 'services upgrade': { 0: SERVICE, 2: SLUG },
+    'compute always-on': { 0: ON_OFF }, 'db always-on': { 0: ON_OFF }, metrics: { 0: TARGET }, logs: { 0: TARGET },
+    'template info': { 0: SLUG }, 'billing upgrade': { 0: oneOf(['pro', 'team']) },
+    'approvals approve': { 0: ID }, 'approvals deny': { 0: ID },
+    'policy set': { 0: POLICY_ACTION, 1: oneOf(['allow', 'deny', 'approve']) }, autoupdate: { 0: ON_OFF },
+};
+const SAFE_OPTIONS = {
+    org: ID, project: ID, region: REGION, env: ENV, oauth: oneOf(['github', 'google']),
+    agent: oneOf(['claude-code', 'cursor', 'codex', 'opencode', 'copilot', 'factory-droid']),
+    type: oneOf(TYPES), component: oneOf(COMPONENTS), severity: oneOf(SEVERITIES),
+    status: oneOf(['pending', 'granted', 'denied', 'consumed']),
+    limit: NUMBER, step: NUMBER, since: NUMBER, port: NUMBER, memory: NUMBER, cpu: NUMBER, size: NUMBER, volume: NUMBER,
+};
+export function telemetryDisabled(env = process.env) {
+    return !!(env.DO_NOT_TRACK || env.INSTA_NO_TELEMETRY);
+}
+/** The PostHog project of the environment `apiUrl` belongs to; a custom host (insta-oss, a preview
+ *  deployment) captures nothing. */
+export function telemetryKey(apiUrl) {
+    const name = envForApiUrl(apiUrl);
+    return name ? PROJECT_KEYS[name] : undefined;
+}
+export function redactOptions(opts) {
+    const out = {};
+    for (const [k, v] of Object.entries(opts)) {
+        if (typeof v === 'boolean' || typeof v === 'number')
+            out[k] = v;
+        else if (typeof v === 'string' && SAFE_OPTIONS[k]?.(v))
+            out[k] = v;
+        else
+            out[k] = REDACTED;
+    }
+    return out;
+}
+export function redactArgs(command, args) {
+    const checks = SAFE_ARGS[command] ?? {};
+    return args.map((a, i) => (a === undefined ? null : typeof a === 'string' && checks[i]?.(a) ? a : REDACTED));
+}
+/** The deployment a `login --env|--api-url` targets. It is persisted only when the login succeeds, so
+ *  a failed attempt must be routed from the options, never from the previous configuration. */
+export function loginTarget(command, opts) {
+    if (command !== 'login')
+        return undefined;
+    if (typeof opts.apiUrl === 'string')
+        return opts.apiUrl;
+    const env = typeof opts.env === 'string' ? opts.env.trim().toLowerCase() : '';
+    return isEnvName(env) ? ENVS[env].api : undefined;
+}
+/** `secrets set`, `services add`, … — the subcommand chain without the program name. */
+export function commandPath(cmd) {
+    const names = [];
+    for (let c = cmd; c?.parent; c = c.parent)
+        names.unshift(c.name());
+    return names.join(' ');
+}
+export function detectAgent(env = process.env) {
+    if (env.CLAUDECODE)
+        return 'claude-code';
+    if (env.CURSOR_TRACE_ID)
+        return 'cursor';
+    return null;
+}
+function errorProps(error) {
+    if (error === undefined || error instanceof CliCancel)
+        return {};
+    if (error instanceof ApiError)
+        return { error_type: 'api', http_status: error.status };
+    if (error instanceof CliExit)
+        return { error_type: 'cli' };
+    const e = error;
+    return { error_type: e?.name ?? 'unknown', ...(e?.cause?.code ? { error_code: e.cause.code } : {}) };
+}
+function hostOf(url) {
+    try {
+        return new URL(url).host;
+    }
+    catch {
+        return null;
+    }
+}
+export function buildCommandEvent(command, args, options, outcome, ctx) {
+    const token = ctx.config.accessToken;
+    const cancelled = outcome.error instanceof CliCancel;
+    const ranChild = outcome.childExitCode !== undefined && outcome.error === undefined;
+    return {
+        event: 'cli_command',
+        distinct_id: ctx.config.user?.id ?? ctx.anonymousId,
+        timestamp: new Date().toISOString(),
+        properties: {
+            command,
+            args: redactArgs(command, args),
+            options: redactOptions(options),
+            success: !cancelled && (outcome.exitCode === 0 || ranChild),
+            cancelled,
+            exit_code: outcome.exitCode,
+            child_exit_code: outcome.childExitCode ?? null,
+            duration_ms: outcome.durationMs,
+            ...errorProps(outcome.error),
+            cli_version: ctx.cliVersion,
+            channel: ctx.channel,
+            node_version: process.version,
+            os: os.platform(),
+            os_release: os.release(),
+            arch: os.arch(),
+            env: envForApiUrl(ctx.config.apiUrl) ?? 'custom',
+            api_host: hostOf(ctx.config.apiUrl),
+            logged_in: !!token,
+            auth_kind: token ? (token.startsWith('insta_') ? 'api_key' : 'session') : null,
+            project_id: ctx.project?.projectId ?? null,
+            org_id: ctx.project?.orgId ?? null,
+            tty: ctx.tty,
+            ci: !!ctx.env.CI,
+            agent: detectAgent(ctx.env),
+            term_program: ctx.env.TERM_PROGRAM ?? null,
+            $lib: 'insta-cli',
+            $lib_version: ctx.cliVersion,
+            ...(ctx.config.user?.id ? {} : { $process_person_profile: false }),
+        },
+    };
+}
+export async function anonymousId(file = join(os.homedir(), '.insta', 'telemetry.json')) {
+    try {
+        const parsed = JSON.parse(await readFile(file, 'utf8'));
+        if (typeof parsed.anonymousId === 'string' && parsed.anonymousId)
+            return parsed.anonymousId;
+    }
+    catch { }
+    const id = randomUUID();
+    try {
+        await mkdir(dirname(file), { recursive: true });
+        await writeFile(file, JSON.stringify({ anonymousId: id }, null, 2));
+    }
+    catch { }
+    return id;
+}
+export async function sendBatch(key, batch, fetchImpl = fetch) {
+    try {
+        const res = await fetchImpl(`${POSTHOG_HOST}/batch/`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ api_key: key, batch }),
+            signal: AbortSignal.timeout(SEND_TIMEOUT_MS),
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+/** Report one finished command. Never throws and never changes the exit code: analytics must not
+ *  fail the user's actual task. */
+export async function trackCommand(cmd, args, outcome, cliVersion, deps = {}) {
+    try {
+        const env = deps.env ?? process.env;
+        if (telemetryDisabled(env))
+            return;
+        const command = commandPath(cmd);
+        if (command.startsWith('__'))
+            return;
+        let config = await (deps.loadConfig ?? readGlobal)();
+        const target = loginTarget(command, cmd.opts());
+        if (target && normalizeUrl(target) !== normalizeUrl(config.apiUrl))
+            config = { apiUrl: target };
+        const key = telemetryKey(config.apiUrl);
+        if (!key)
+            return;
+        const project = await (deps.loadProject ?? readProject)();
+        const event = buildCommandEvent(command, args.flat(), cmd.opts(), outcome, {
+            cliVersion,
+            channel: deps.channel ?? detectChannel(),
+            config,
+            project,
+            anonymousId: await anonymousId(deps.idFile),
+            env,
+            tty: deps.tty ?? !!process.stdout.isTTY,
+        });
+        await sendBatch(key, [event], deps.fetchImpl);
+    }
+    catch { }
+}
+//# sourceMappingURL=telemetry.js.map

package/dist/template-manifest.js

@@ -103,8 +103,16 @@ export function validateManifest(m) {
             problems.push(`${where}: web services must declare a healthcheck path`);
         if (svc.healthcheck && !String(svc.healthcheck).startsWith('/'))
             problems.push(`${where}: healthcheck must be an absolute path (start with /)`);
-        if (svc.volume !== undefined && (!Number.isInteger(svc.volume?.size) || svc.volume.size < 1)) {
-            problems.push(`${where}: volume.size must be a whole Gi ≥ 1, got: ${svc.volume?.size}`);
+        // Sizing is the platform's, capped for the org's plan (insta-platform#357). Same answers the
+        // publish endpoint gives, said here so an author does not upload to find out. Read as unknown:
+        // the type above admits only what is SUPPORTED, and the document is a cast over YAML.parse, so
+        // a refused shape arrives as a value that type does not describe.
+        const authored = svc;
+        if (authored.volume !== undefined && authored.volume !== true) {
+            problems.push(`${where}: the volume size is the platform's to choose — declare 'volume: true'`);
+        }
+        if (authored.spec !== undefined) {
+            problems.push(`${where}: compute size is the platform's to choose — remove spec`);
         }
         const env = svc.env ?? {};
         for (const group of ['fixed', 'generated', 'required', 'optional']) {

package/dist/util.js

@@ -56,6 +56,20 @@ export class CliExit extends Error {
         this.name = 'CliExit';
     }
 }
+let relayedCode;
+/** A child's exit status the CLI passes through as its own (run, db connect, compute exec). */
+export function relayExitCode(code) {
+    relayedCode = code;
+    process.exitCode = code;
+}
+export function relayedExitCode() { return relayedCode; }
+/** The user cancelled an interactive prompt: exit 0 with nothing printed. */
+export class CliCancel extends Error {
+    constructor() {
+        super('cancelled');
+        this.name = 'CliCancel';
+    }
+}
 export function fail(msg) {
     process.stderr.write(`error: ${msg}\n`);
     process.exitCode = 1;

package/package.json

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