insta 0.1.10 → 0.1.12

package/dist/commands/billing.js

@@ -1,4 +1,4 @@
-import { ApiClient, requireProject } from '../api.js';
+import { ApiClient, ApiError, requireProject } from '../api.js';
 import { die, info, openUrl, printJson } from '../util.js';
 import { cycleLine, dimensionLines } from './metrics.js';
 // Resolve the target org: explicit --org, else the linked project's org.
@@ -100,6 +100,63 @@ export async function billingUpgrade(tier, opts) {
         return printJson({ url });
     presentUrl(url, `Subscribe to ${tier} — complete checkout in your browser:`, opts.open);
 }
+// The platform's contract (RedeemError#reason in billing/service.ts) — four literals, never
+// collapsed into one message, because the right next action differs per reason: `not_found` is
+// the only one worth retyping; `expired`/`revoked` both mean waiting never helps, but only
+// `revoked` has someone to go back to.
+//
+// `already_redeemed` deliberately does NOT say WHO redeemed it, because this CLI cannot know.
+// A sequential retry replays the receipt and never reaches here — but two requests from the same
+// org in flight at once both miss the replay read (it sees committed rows only), one wins the
+// claim and the other lands exactly here. That is the case a client resending a request it never
+// saw an answer to is IN. Telling that person "a different org took it" would be false about
+// their own money: the grant is on their wallet. So the message points them at their balance
+// instead of at a conclusion this side cannot support.
+const REDEEM_ERROR_MESSAGE = {
+    not_found: 'that code was not recognized — check it for typos and try again',
+    expired: 'that code has expired — ask whoever sent it for a new one',
+    already_redeemed: 'that code has already been redeemed — if it was your org, the credits are already there (check `insta billing`)',
+    revoked: 'that code was revoked — contact whoever sent it to you',
+};
+// Pure — the human line for a redeem failure. `reason` is the platform's literal (RedeemError's
+// four values); anything else (a platform version ahead of this CLI) falls back to relaying it
+// as-is rather than a message that would be wrong about which of the four cases this is.
+export function redeemErrorMessage(reason, fallback) {
+    return (reason && REDEEM_ERROR_MESSAGE[reason]) ?? fallback;
+}
+// Pure — the three facts the spec names, in the order it names them: what landed, when it stops
+// being spendable, and which org — by NAME — so someone who belongs to several orgs isn't left
+// reading a uuid to find out which one just got the money.
+export function redeemLines(r) {
+    return [
+        `credited:        $${(r.amountMicros / 1_000_000).toFixed(2)}`,
+        `expires:         ${r.creditsExpireAt ? r.creditsExpireAt.slice(0, 10) : 'never'}`,
+        `org:             ${r.orgName}`,
+    ];
+}
+// insta billing redeem <code> — apply a one-time credit code to the org's wallet.
+export async function billingRedeem(code, opts) {
+    const api = await ApiClient.load();
+    const orgId = await resolveOrgId(opts);
+    let res;
+    try {
+        res = await api.request('POST', `/orgs/${orgId}/billing/redeem`, { code });
+    }
+    catch (e) {
+        if (!(e instanceof ApiError) || e.status !== 400)
+            throw e;
+        // Under --json, stdout stays the one parseable document a script branches on (the platform's
+        // own `error` literal); the human line below is the diagnostic and belongs on stderr.
+        const reason = e.body?.error;
+        if (opts.json)
+            printJson({ error: reason ?? e.message });
+        die(redeemErrorMessage(reason, e.message));
+    }
+    if (opts.json)
+        return printJson(res);
+    for (const l of redeemLines(res))
+        info(l);
+}
 // insta billing portal — open the Stripe Customer Portal (change plan / card / cancel).
 export async function billingPortal(opts) {
     const api = await ApiClient.load();

package/dist/commands/postgres.js

@@ -3,13 +3,22 @@ import { constants as osConstants } from 'node:os';
 import { ApiClient, ApiError, requireProject } from '../api.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
-// actual usage). Thin wrapper over PATCH /database/settings {scaleToZero} — insta-db-backed
-// postgres only.
-export async function dbAlwaysOn(mode, service, opts) {
-    if (mode !== 'on' && mode !== 'off')
+export function alwaysOnArgs(first, second) {
+    if (first === 'on' || first === 'off')
+        return { mode: first, service: second };
+    if (second !== undefined)
         throw new Error('mode must be on|off');
+    return { service: first };
+}
+export function alwaysOnLine(group, scaleToZero) {
+    return `postgres ${group}: always-on ${scaleToZero === false ? 'on — instance stays warm' : scaleToZero === true ? 'off — scales to zero when idle' : 'unknown — the provider did not report it'}`;
+}
+// Show or set a postgres service's idle mode: scale-to-zero (the default: instance suspends when
+// idle, cold-starts on the next connection) or always-on (instance stays warm; idle RAM bills at
+// actual usage). Reads GET /database/instance, sets PATCH /database/settings {scaleToZero} —
+// insta-db-backed postgres only.
+export async function dbAlwaysOn(first, second, opts) {
+    const { mode, service } = alwaysOnArgs(first, second);
     const api = await ApiClient.load();
     const p = await requireProject();
     const qs = new URLSearchParams();
@@ -18,13 +27,49 @@ export async function dbAlwaysOn(mode, service, opts) {
         qs.set('branch', branch);
     if (service)
         qs.set('group', service);
-    const res = await api.rawRequest('PATCH', `/projects/${p.projectId}/database/settings${qs.toString() ? `?${qs}` : ''}`, { scaleToZero: mode !== 'on' });
+    const suffix = qs.toString() ? `?${qs}` : '';
+    if (!mode) {
+        const read = await fetchDbInstance(api, p.projectId, suffix);
+        if (read.kind === 'no-instance') {
+            info(`postgres ${service ?? 'default'}: no manageable instance (this service manages its own resources)`);
+            return;
+        }
+        if (opts.json)
+            return printJson(read.body);
+        info(alwaysOnLine(service ?? 'default', read.body?.scaleToZero));
+        return;
+    }
+    const res = await api.rawRequest('PATCH', `/projects/${p.projectId}/database/settings${suffix}`, { scaleToZero: mode !== 'on' });
     if (handleApproval(res, opts.json))
         return;
+    const body = await settleScaleToZero(res.body, mode === 'off', async () => {
+        try {
+            return (await api.rawRequest('GET', `/projects/${p.projectId}/database/instance${suffix}`, undefined, { signal: AbortSignal.timeout(5000) })).body;
+        }
+        catch {
+            return undefined;
+        }
+    });
     if (opts.json)
-        return printJson(res.body);
-    const s2z = res.body?.scaleToZero;
-    info(`postgres ${service ?? 'default'}: always-on ${s2z === false ? 'ENABLED — instance stays warm (no cold starts; idle RAM bills at actual usage)' : 'disabled — scales to zero when idle (default; first connection after idle cold-starts)'}`);
+        return printJson(body);
+    info(alwaysOnSetLine(service, opts.branch, mode, body?.scaleToZero));
+}
+// insta-db applies the change asynchronously and answers with the value from before it, so re-read until they agree.
+export async function settleScaleToZero(body, want, read, wait = (ms) => new Promise((r) => setTimeout(r, ms))) {
+    for (let i = 0; i < 15 && typeof body?.scaleToZero === 'boolean' && body.scaleToZero !== want; i++) {
+        await wait(2000);
+        const next = await read();
+        if (next === undefined)
+            break;
+        body = next;
+    }
+    return body;
+}
+export function alwaysOnSetLine(service, branch, mode, scaleToZero) {
+    const group = service ?? 'default';
+    if (scaleToZero !== (mode === 'off'))
+        return `postgres ${group}: always-on ${mode} requested — the database has not applied it yet; confirm with \`insta postgres always-on${service ? ` ${service}` : ''}${branch ? ` --branch ${branch}` : ''}\``;
+    return `postgres ${group}: always-on ${mode === 'on' ? 'ENABLED — instance stays warm (no cold starts; idle RAM bills at actual usage)' : 'disabled — scales to zero when idle (default; first connection after idle cold-starts)'}`;
 }
 // Validated pass-throughs for the provider's quantity strings. The insta-db resize API takes
 // k8s-style quantities (cpu: "2", "2500m"; memory: "4Gi", "2048Mi"), so unlike the compute path

package/dist/index.js

@@ -36,7 +36,7 @@ import * as template from './commands/template.js';
 import * as govern from './commands/govern.js';
 import * as observe from './commands/observe.js';
 import * as obs from './commands/metrics.js';
-import { billing, billingUpgrade, billingPortal } from './commands/billing.js';
+import { billing, billingUpgrade, billingPortal, billingRedeem } from './commands/billing.js';
 import * as domainCmd from './commands/domain.js';
 import * as selfUpdate from './commands/upgrade.js';
 import * as feedbackCmd from './commands/feedback.js';
@@ -438,7 +438,7 @@ pg.command('volume [service]').description("Show or grow a postgres service's pr
     .option('--size <gi>', 'new size in whole Gi, e.g. 10 (must be ≥ the current size)')
     .option('--json').option('--branch <branch>', 'branch (default: current)')
     .action(guard((service, o) => pgCmd.dbVolume(service, o)));
-pg.command('always-on <mode> [service]').description('Set a postgres service always-on (mode: on|off). on = instance stays warm, no cold starts; off = default scale-to-zero (idle instance suspends; first connection cold-starts). insta-db-backed services only')
+pg.command('always-on [mode] [service]').description('Show or set a postgres service always-on (mode: on|off; no mode = print the current setting). on = instance stays warm, no cold starts; off = default scale-to-zero (idle instance suspends; first connection cold-starts). insta-db-backed services only')
     .option('--json').option('--branch <branch>', 'branch (default: current)')
     .action(guard((mode, service, o) => pgCmd.dbAlwaysOn(mode, service, o)));
 addObservability(pg, 'db', 'postgres');
@@ -530,7 +530,7 @@ tpl.command('deploy <code-or-dir-or-url>').description('Deploy a template onto a
     .option('--json')
     .action(guard((target, o) => template.templateDeploy(target, o)));
 // ---- billing ----
-const bill = program.command('billing').description('Billing: current cycle overview (bare), subscribe to a tier, Stripe portal, usage by dimension')
+const bill = program.command('billing').description('Billing: current cycle overview (bare), subscribe to a tier, redeem a credit code, Stripe portal, usage by dimension')
     .option('--org <id>', 'target org (default: linked project\'s org)').option('--json')
     .action(guard((o) => billing(o)));
 // commander 12 defaults allowExcessArguments to true, so a mistyped/retired subcommand (e.g.
@@ -539,6 +539,9 @@ bill.allowExcessArguments(false);
 bill.command('subscribe <tier>').description('Subscribe the org to a paid tier (pro|team) via Stripe Checkout')
     .option('--org <id>').option('--no-open', 'print the URL instead of opening a browser').option('--json')
     .action(guard((tier, o) => billingUpgrade(tier, o)));
+bill.command('redeem <code>').description("Redeem a one-time credit code into the org's wallet")
+    .option('--org <id>').option('--json')
+    .action(guard((code, o) => billingRedeem(code, o)));
 bill.command('portal').description('Open the Stripe Customer Portal (change plan / card / cancel)')
     .option('--org <id>').option('--no-open', 'print the URL instead of opening a browser').option('--json')
     .action(guard((o) => billingPortal(o)));

package/package.json

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