insta 0.0.53 → 0.0.55

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/services.js

@@ -16,11 +16,13 @@ export function assertServiceName(name) {
     if (!SERVICE_NAME_RE.test(name))
         throw new Error('service name must be lower-kebab (a-z, 0-9, -)');
 }
-// Parse a positive-integer machine count.
+const MAX_COMPUTE_REPLICAS = 10;
+// Parse a replica count inside the compute plane's current safety ceiling.
 export function parseCount(raw) {
     const n = Number(raw);
-    if (!Number.isInteger(n) || n < 1)
-        throw new Error(`count must be a positive integer, got: ${raw}`);
+    if (!Number.isInteger(n) || n < 1 || n > MAX_COMPUTE_REPLICAS) {
+        throw new Error(`count must be an integer between 1 and ${MAX_COMPUTE_REPLICAS}, got: ${raw}`);
+    }
     return n;
 }
 // Parse a TCP port. Junk fails here rather than reaching the API as NaN (the parseCpu lesson).
@@ -216,7 +218,7 @@ export async function servicesScale(type, name, number, region, _opts) {
         return;
     if (_opts.json)
         return printJson(res.body.service);
-    info(`scaled compute ${name} to ${machineCount} machine(s)${region ? ` in ${region}` : ''}`);
+    info(`scaled compute ${name} to ${machineCount} replica(s)${region ? ` in ${region}` : ''}`);
 }
 // insta services upgrade <compute|postgres> <name> <new-spec>
 export async function servicesUpgrade(type, name, spec, _opts) {

package/dist/commands/template.js

@@ -7,18 +7,20 @@ 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.
 export function templateListLines(templates) {
     if (!templates.length)
         return ['(no templates published yet)'];
-    const head = ['CODE', 'VERSION', 'CATEGORY', 'VARS', 'DEPLOYS', 'NAME'];
+    const head = ['CODE', 'VERSION', 'CATEGORY', 'PROJECTS', 'SUCCESS', 'NAME'];
     const numeric = [false, false, false, true, true, false];
     const rows = templates.map((t) => [
         t.code, t.version ?? '', t.category ?? '-',
-        String(t.requiredVarCount ?? 0), String(t.deployCount ?? 0),
+        String(t.totalProjects ?? 0),
+        // null = nothing has concluded yet; the platform never sends 0 for that.
+        t.successRate == null ? '-' : `${t.successRate}%`,
         t.tagline ? `${t.name} — ${t.tagline}` : (t.name ?? ''),
     ]);
     const widths = head.map((h, i) => Math.max(h.length, ...rows.map((r) => r[i].length)));
@@ -148,12 +150,12 @@ export async function resolveVariables(vars, given, opts = {}) {
     return values;
 }
 // The platform's machine-readable "you forgot these" answer to the POST (error=missing_variables,
-// missing: [{name, key, description}] with a missingVariables alias) — turned back into promptable
-// variables. null = some other error, not ours to interpret.
+// missing: [{name, key, description}]) — turned back into promptable variables. null = some other
+// error, not ours to interpret.
 export function missingVariablesFrom(body) {
     if ((body?.error ?? body?.code) !== 'missing_variables')
         return null;
-    const list = body?.missing ?? body?.missingVariables ?? [];
+    const list = body?.missing ?? [];
     if (!Array.isArray(list))
         return [];
     return list.map((v) => ({ name: String(v.name ?? v.key ?? v), required: true, description: v.description }));
@@ -296,7 +298,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
@@ -145,7 +160,7 @@ svc.command('rename <type> <name> <new-name>').description('Rename a service and
     .action(guard((type, name, newName, o) => services.servicesRename(type, name, newName, o)));
 svc.command('set-access <type> <name> <access>').description('Set a storage service bucket access mode (access: public|private)')
     .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)')
+svc.command('scale <type> <name> <number> [region]').description('Set a compute service same-region replica count from 1 to 10 (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 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)));

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/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.53",
+  "version": "0.0.55",
   "type": "module",
   "description": "InstaCloud CLI — a thin client of the platform control-plane API.",
   "keywords": [