insta 0.0.35 → 0.0.37

package/README.md

@@ -26,14 +26,25 @@ npm install -g insta
 ```
 
 For coding agents. Installs the CLI, the `insta` skill for every agent on the machine, and
-registers the MCP server:
+registers the MCP server — one command for macOS, Linux, WSL, and native Windows shells
+(PowerShell/cmd). Needs Node 18+ with a writable npm global prefix (a Node version manager
+qualifies; if the global install can't write, setup continues and prints the exact
+version-pinned `npm install -g` fallback to run yourself). E2e-validated on macOS/Linux; the
+Windows spawn paths are unit-tested:
 
 ```bash
-curl -fsSL agents.instacloud.com | sh
+npx -y insta setup agent
 ```
 
-On Windows, download `insta-windows-x64.exe` from the
-[releases page](https://github.com/InsForge/insta-cli/releases).
+On macOS/Linux without Node, the native-binary installer puts the `insta` CLI on PATH (the
+skill + MCP steps it then runs still need Node — the skills tool runs via npx). Never run it
+on native Windows — PowerShell's `curl` alias and the WSL `bash` shim break it; use npx
+above, or download `insta-windows-x64.exe` from the
+[releases page](https://github.com/InsForge/insta-cli/releases):
+
+```bash
+curl -fsSL agents.instacloud.com | sh
+```
 
 Pin a version with `INSTA_VERSION=v0.0.22`; change the install directory with
 `INSTA_INSTALL_DIR`. While the CLI is pre-1.0 it updates itself on new releases. Turn that
@@ -101,7 +112,8 @@ prints an approval id for an admin to grant with `insta approvals approve <id>`.
 
 `insta manifest` prints an agent-legible view of every branch and its URLs. `insta setup
 agent` installs the InstaCloud skill and registers the remote MCP server for the coding
-agents on the machine.
+agents on the machine — and, when running from the npx cache with no durable `insta` on
+PATH, first installs the CLI itself globally.
 
 ## Environments
 
@@ -167,7 +179,7 @@ build never reaches a production installer.
 |---|---|
 | `insta login` · `logout` · `status` | Email/password or `--oauth github\|google`; `status` shows the environment, login and linked project/branch |
 | `insta env` | `show` · `use <prod\|staging>` |
-| `insta setup` | `agent` — install the skill and register MCP for every coding agent |
+| `insta setup` | `agent` — install the CLI (if missing), the skill, and MCP for every coding agent |
 | `insta mcp` | `install` — register the remote MCP server only |
 | `insta org` | `list` · `create` (one free org per user) |
 | `insta project` | `create` · `list` · `link` · `delete` |

package/dist/api.js

@@ -2,7 +2,7 @@
 // 2xx (including 202 approval_required) returns the parsed body; >=400 throws ApiError.
 import { readGlobal, writeGlobal, readProject, writeProject } from './config.js';
 import { autoResolveProject, promptChoice } from './resolve-project.js';
-import { die, info } from './util.js';
+import { die } from './util.js';
 export class ApiError extends Error {
     status;
     constructor(status, msg) {
@@ -117,7 +117,9 @@ export async function requireProject() {
             promptChoice,
             save: async (c) => {
                 await writeProject(c);
-                info(`auto-linked project ${c.projectId} → ./.insta/project.json`);
+                // stderr: this is a diagnostic that can precede ANY command's output — under --json,
+                // stdout must stay one parseable document.
+                process.stderr.write(`auto-linked project ${c.projectId} → ./.insta/project.json\n`);
             },
             tty: !!process.stdin.isTTY && !!process.stderr.isTTY,
         });

package/dist/commands/branch.js

@@ -5,6 +5,8 @@ export async function branchCreate(name, opts) {
     const api = await ApiClient.load();
     const p = await requireProject();
     const out = await api.request('POST', `/projects/${p.projectId}/branches`, { name, from: opts.from ?? p.branch });
+    if (opts.json)
+        return printJson(out);
     info(`created branch ${out.branch.name} (${out.branch.id})`);
     renderNextActions(out.nextActions);
 }
@@ -17,16 +19,18 @@ export async function branchList(opts) {
     for (const b of branches)
         info(`${b.is_default ? '*' : ' '} ${b.name}  [${b.status}]  ${b.id}`);
 }
-export async function branchSwitch(name) {
+export async function branchSwitch(name, opts = {}) {
     const api = await ApiClient.load();
     const p = await requireProject();
     const { branches } = await api.request('GET', `/projects/${p.projectId}/branches`);
     if (!branches.some((b) => b.name === name))
         die(`branch not found: ${name}`);
     await writeProject({ ...p, branch: name });
+    if (opts.json)
+        return printJson({ projectId: p.projectId, branch: name });
     info(`switched to branch ${name} — run \`insta secrets\` to refresh .env`);
 }
-export async function branchDelete(name) {
+export async function branchDelete(name, opts = {}) {
     const api = await ApiClient.load();
     const p = await requireProject();
     const { branches } = await api.request('GET', `/projects/${p.projectId}/branches`);
@@ -34,8 +38,10 @@ export async function branchDelete(name) {
     if (!b)
         die(`branch not found: ${name}`);
     const res = await api.rawRequest('DELETE', `/projects/${p.projectId}/branches/${b.id}`);
-    if (handleApproval(res))
+    if (handleApproval(res, opts.json))
         return;
+    if (opts.json)
+        return printJson({ ok: true, branch: { id: b.id, name: b.name } });
     info(`deleted branch ${name}`);
 }
 // insta branch merge <source> [--into <target>] — structurally merge source's services into target
@@ -47,8 +53,10 @@ export async function branchMerge(source, opts = {}) {
     if (!target)
         throw new Error('no target branch — pass --into <branch> (or link a branch first)');
     const res = await api.rawRequest('POST', `/projects/${p.projectId}/branches/${encodeURIComponent(target)}/merge`, { from: source });
-    if (handleApproval(res))
+    if (handleApproval(res, opts.json))
         return;
+    if (opts.json)
+        return printJson(res.body ?? {});
     const { created = [], skipped = [] } = (res.body ?? {});
     info(`merged ${source} → ${target}: ${created.length} created, ${skipped.length} skipped`);
     for (const c of created)

package/dist/commands/build.js

@@ -0,0 +1,256 @@
+// `insta build` — pre-push verification of a source directory: the detection plan (what would
+// build), the Dockerfile that would be used (yours, or nixpacks-generated), and static checks.
+// Entirely local and offline: no login, no project link, nothing pushed or deployed. Phase 1 is
+// static-only — no Docker daemon involved.
+import { resolve, join } from 'node:path';
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { info, printJson, die } from '../util.js';
+import { dockerfileExposedPort } from './deploy.js';
+import { nixpacksPlan, nixpacksGeneratedDockerfile, nixpacksAvailable, quietRunner } from '../nixpacks.js';
+// A failed critical sinks the build; a failed warning deserves attention; skips are not failures.
+export function computeVerdict(checks) {
+    const failed = checks.filter((c) => c.status === 'fail');
+    if (failed.some((c) => c.severity === 'critical'))
+        return 'failed';
+    if (failed.length > 0)
+        return 'needs-attention';
+    return 'deployable';
+}
+// Port resolution mirrors deploy.ts: an explicit --port wins, else the Dockerfile's EXPOSE. The
+// rationale string is part of the output — every plan line says why (the `fly launch` pattern).
+export function inferPort(flag, dockerfile) {
+    if (flag !== undefined) {
+        const port = /^\d+$/.test(flag.trim()) ? Number(flag.trim()) : NaN;
+        if (!Number.isInteger(port) || port < 1 || port > 65535)
+            throw new Error(`--port must be an integer between 1 and 65535, got: ${flag}`);
+        return { port, rationale: '--port flag' };
+    }
+    const exposed = dockerfile ? dockerfileExposedPort(dockerfile) : undefined;
+    if (exposed)
+        return { port: exposed, rationale: `Dockerfile EXPOSE ${exposed}` };
+    return { port: undefined, rationale: 'not detected — deploy defaults to 8080' };
+}
+// Keys the app expects, from .env.example — surfaced so an agent can `insta secrets set` them
+// before the first deploy instead of discovering missing config from runtime crashes.
+export function envKeysFromDotEnvExample(content) {
+    const keys = [];
+    for (const line of content.split('\n')) {
+        if (line.trim().startsWith('#'))
+            continue;
+        const key = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/.exec(line)?.[1];
+        if (key)
+            keys.push(key);
+    }
+    return keys;
+}
+const CONTEXT_WARN_BYTES = 100 * 1024 * 1024;
+const WALK_CAP = 50_000; // entries; hitting it marks the stats truncated (size becomes a floor)
+// Sizes what would actually ship: a dockerignored node_modules is skipped, not counted. (Only the
+// node_modules pattern is honored — full .dockerignore glob semantics aren't reimplemented here.)
+export function contextStats(dir, cap = WALK_CAP) {
+    const ignoreFile = join(dir, '.dockerignore');
+    const ignoreLines = existsSync(ignoreFile)
+        ? readFileSync(ignoreFile, 'utf8').split('\n').map((l) => l.trim()).filter((l) => l && !l.startsWith('#'))
+        : [];
+    const nodeModulesIgnored = ignoreLines.some((l) => ['node_modules', 'node_modules/', '/node_modules', '**/node_modules'].includes(l));
+    let totalBytes = 0;
+    let nodeModulesBytes = 0;
+    let hasNodeModules = false;
+    let truncated = false;
+    let seen = 0;
+    const walk = (d, inNodeModules) => {
+        let entries;
+        try {
+            entries = readdirSync(d);
+        }
+        catch {
+            return;
+        }
+        for (const name of entries) {
+            if (seen++ >= cap) {
+                truncated = true;
+                return;
+            }
+            if (name === '.git')
+                continue;
+            const p = join(d, name);
+            let st;
+            try {
+                st = statSync(p);
+            }
+            catch {
+                continue;
+            }
+            if (name === 'node_modules' && st.isDirectory()) {
+                hasNodeModules = true;
+                if (nodeModulesIgnored)
+                    continue; // excluded from the context — don't count it
+            }
+            const isNm = inNodeModules || name === 'node_modules';
+            if (st.isDirectory())
+                walk(p, isNm);
+            else {
+                totalBytes += st.size;
+                if (isNm)
+                    nodeModulesBytes += st.size;
+            }
+        }
+    };
+    walk(dir, false);
+    return { totalBytes, nodeModulesBytes, hasNodeModules, nodeModulesIgnored, truncated };
+}
+const mb = (bytes) => `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+export function contextCheck(ctx) {
+    const shipsNodeModules = ctx.hasNodeModules && !ctx.nodeModulesIgnored;
+    const tooBig = ctx.totalBytes > CONTEXT_WARN_BYTES;
+    const size = `${mb(ctx.totalBytes)}${ctx.truncated ? '+' : ''}`;
+    const detail = shipsNodeModules
+        ? `node_modules (${mb(ctx.nodeModulesBytes)}) would ship in the ${size} build context`
+        : ctx.truncated
+            ? `over ${WALK_CAP.toLocaleString('en-US')} entries — scan truncated, ${size} is a floor`
+            : `${size}${tooBig ? ' — large contexts make remote builds slow' : ''}`;
+    const bad = shipsNodeModules || tooBig || ctx.truncated;
+    return {
+        id: 'context',
+        severity: 'warning',
+        status: bad ? 'fail' : 'pass',
+        title: 'build context',
+        detail,
+        ...(bad ? { nextAction: 'add a .dockerignore (node_modules, build artifacts, secrets)' } : {}),
+    };
+}
+export async function buildReport(dirArg, opts, deps) {
+    const dir = resolve(process.cwd(), dirArg);
+    const userDockerfilePath = join(dir, 'Dockerfile');
+    const hasUserDockerfile = existsSync(userDockerfilePath);
+    let dockerfile = { source: null };
+    let np = null;
+    let dockerfileDetail = '';
+    if (hasUserDockerfile) {
+        dockerfile = { source: 'user', path: userDockerfilePath, content: readFileSync(userDockerfilePath, 'utf8') };
+        dockerfileDetail = 'using the Dockerfile in the directory';
+    }
+    else if (!deps.nixpacksAvailable) {
+        dockerfileDetail = 'no Dockerfile in the directory, and nixpacks is not installed to generate one';
+    }
+    else {
+        np = await nixpacksPlan(dir, deps.runner);
+        if (!np) {
+            dockerfileDetail = 'no Dockerfile, and nixpacks matched no provider for this directory';
+        }
+        else {
+            const generated = await nixpacksGeneratedDockerfile(dir, deps.runner);
+            if (generated) {
+                dockerfile = { source: 'nixpacks', content: generated };
+                dockerfileDetail = `generated by nixpacks (providers: ${np.providers.join(', ') || 'none'})`;
+            }
+            else {
+                dockerfileDetail = 'nixpacks detected the app but could not generate a Dockerfile';
+            }
+        }
+    }
+    const builder = hasUserDockerfile ? 'dockerfile' : np ? 'nixpacks' : null;
+    const { port, rationale } = inferPort(opts.port, dockerfile.content);
+    const envExample = join(dir, '.env.example');
+    const envKeys = existsSync(envExample) ? envKeysFromDotEnvExample(readFileSync(envExample, 'utf8')) : [];
+    const checks = [];
+    checks.push({
+        id: 'dockerfile',
+        severity: 'critical',
+        status: dockerfile.source ? 'pass' : 'fail',
+        title: 'Dockerfile',
+        detail: dockerfileDetail,
+        ...(dockerfile.source ? {} : { nextAction: `add a Dockerfile at ${userDockerfilePath}, or install nixpacks (https://nixpacks.com/docs/install) so insta can generate one` }),
+    });
+    if (builder === 'dockerfile') {
+        const hasCmd = /^\s*(CMD|ENTRYPOINT)\s/im.test(dockerfile.content ?? '');
+        checks.push({
+            id: 'start-command',
+            severity: 'warning',
+            status: hasCmd ? 'pass' : 'fail',
+            title: 'start command',
+            detail: hasCmd ? 'Dockerfile has a CMD/ENTRYPOINT' : 'no CMD or ENTRYPOINT in the Dockerfile — the base image must supply one',
+            ...(hasCmd ? {} : { nextAction: 'add a CMD (or ENTRYPOINT) so the image starts your app' }),
+        });
+    }
+    else if (builder === 'nixpacks') {
+        checks.push({
+            id: 'start-command',
+            severity: 'critical',
+            status: np?.startCommand ? 'pass' : 'fail',
+            title: 'start command',
+            detail: np?.startCommand ?? 'nixpacks found no start command — the built image would not run',
+            ...(np?.startCommand ? {} : { nextAction: 'define one (e.g. a package.json "start" script, or a Procfile)' }),
+        });
+    }
+    else {
+        checks.push({ id: 'start-command', severity: 'critical', status: 'skip', title: 'start command', detail: 'skipped — no builder' });
+    }
+    checks.push({
+        id: 'port',
+        severity: 'warning',
+        status: port !== undefined ? 'pass' : 'fail',
+        title: 'port',
+        detail: port !== undefined ? `${port} (${rationale})` : rationale,
+        ...(port !== undefined ? {} : { nextAction: 'pass --port <n> (or add EXPOSE <n> to the Dockerfile) — a port mismatch is the #1 deploy mistake' }),
+    });
+    checks.push(contextCheck(contextStats(dir)));
+    return {
+        dir,
+        plan: { builder, providers: np?.providers ?? [], installCommand: np?.installCommand, buildCommand: np?.buildCommand, startCommand: np?.startCommand, port, portRationale: rationale, envKeys },
+        dockerfile,
+        checks,
+        verdict: computeVerdict(checks),
+    };
+}
+const MARK = { pass: '✓', fail: '✗', skip: '·' };
+export function renderReport(r, explain) {
+    const lines = [];
+    lines.push(`plan for ${r.dir}:`);
+    lines.push(`  builder: ${r.plan.builder ?? 'none'}${r.plan.providers.length ? ` (providers: ${r.plan.providers.join(', ')})` : ''}`);
+    if (r.plan.installCommand)
+        lines.push(`  install: ${r.plan.installCommand}`);
+    if (r.plan.buildCommand)
+        lines.push(`  build:   ${r.plan.buildCommand}`);
+    if (r.plan.startCommand)
+        lines.push(`  start:   ${r.plan.startCommand}`);
+    lines.push(`  port:    ${r.plan.port ?? '?'} (${r.plan.portRationale})`);
+    if (r.plan.envKeys.length)
+        lines.push(`  env keys (.env.example): ${r.plan.envKeys.join(', ')}`);
+    lines.push('checks:');
+    for (const c of r.checks) {
+        const mark = c.status === 'fail' && c.severity !== 'critical' ? '⚠' : MARK[c.status];
+        lines.push(`  ${mark} ${c.title}${c.detail ? ` — ${c.detail}` : ''}`);
+        if (c.status === 'fail' && c.nextAction)
+            lines.push(`      → ${c.nextAction}`);
+    }
+    if (explain && r.dockerfile.content) {
+        lines.push(`dockerfile (${r.dockerfile.source}):`);
+        for (const l of r.dockerfile.content.trimEnd().split('\n'))
+            lines.push(`  ${l}`);
+    }
+    lines.push(`verdict: ${r.verdict}`);
+    return lines;
+}
+// Dockerfile content is included with --explain; without it the report stays small.
+export function jsonReport(report, explain) {
+    return explain ? report : { ...report, dockerfile: { ...report.dockerfile, content: undefined } };
+}
+export async function build(dirArg, opts) {
+    const dir = dirArg ?? '.';
+    const abs = resolve(process.cwd(), dir);
+    if (!existsSync(abs) || !statSync(abs).isDirectory())
+        die(`no such directory: ${abs}`);
+    // Only probe for nixpacks when there is no Dockerfile to verify. The probe is silent and never
+    // installs anything — stdout must stay pure for --json, and a verifier must stay offline.
+    const available = existsSync(join(abs, 'Dockerfile')) ? false : await nixpacksAvailable();
+    const report = await buildReport(dir, opts, { runner: quietRunner, nixpacksAvailable: available });
+    if (opts.json)
+        printJson(jsonReport(report, !!opts.explain));
+    else
+        for (const line of renderReport(report, !!opts.explain))
+            info(line);
+    if (report.verdict === 'failed')
+        process.exitCode = 1;
+}
+//# sourceMappingURL=build.js.map

package/dist/commands/compute.js

@@ -7,7 +7,7 @@ export async function setDomain(host, opts) {
     const api = await ApiClient.load();
     const p = await requireProject();
     const res = await api.rawRequest('POST', `/projects/${p.projectId}/compute/domain`, { hostname: host, branch: opts.branch ?? p.branch, group: opts.group });
-    if (handleApproval(res))
+    if (handleApproval(res, opts.json))
         return;
     printDomain(res.body, opts.json);
 }
@@ -26,9 +26,16 @@ export async function removeDomain(host, opts) {
     const api = await ApiClient.load();
     const p = await requireProject();
     const res = await api.rawRequest('DELETE', `/projects/${p.projectId}/compute/domain`, { hostname: host, branch: opts.branch ?? p.branch, group: opts.group });
-    if (handleApproval(res))
+    if (handleApproval(res, opts.json))
         return;
-    info(`removed custom domain ${res.body.hostname} from ${res.body.flyApp}`);
+    renderRemoveDomain(res.body, opts.json);
+}
+// Split out (same pattern as applyExecResult) so the --json contract — stdout carries the platform
+// response, never prose — is unit-testable without a network mock.
+export function renderRemoveDomain(body, json) {
+    if (json)
+        return printJson(body);
+    info(`removed custom domain ${body.hostname} from ${body.flyApp}`);
 }
 function printDomain(r, json) {
     if (json)
@@ -50,7 +57,7 @@ async function lifecycle(verb, serviceName, opts) {
     const { services } = await api.request('GET', `/projects/${p.projectId}/services${q(branch)}`);
     const id = resolveComputeServiceId(services, serviceName);
     const res = await api.rawRequest('POST', `/projects/${p.projectId}/services/${id}/${verb}`);
-    if (handleApproval(res))
+    if (handleApproval(res, opts.json))
         return;
     if (opts.json)
         return printJson(res.body);
@@ -70,6 +77,90 @@ export async function computeStatus(serviceName, opts) {
         return printJson(r);
     info(`compute ${serviceName ?? id}: desired=${r.desiredState}  live=${r.state}`);
 }
+// ---- exec (one-shot command; no interactive shell/PTY) ----
+// `insta compute exec [service] -- <command> [args…]`: the command must reach the platform
+// byte-for-byte and can itself contain dashes or another `--`, so it can't be a normal commander
+// positional — with `service` optional, commander flattens everything past the literal `--` into
+// one operand list and has no way to tell "no service, command starts here" apart from "service IS
+// the first command token". Splitting argv on the first literal `--` after `compute exec`
+// ourselves, before commander ever parses it, removes the ambiguity; this is the only place in the
+// whole CLI a bare `--` has this meaning, so nothing else is affected. Exported for a direct,
+// network-free unit test — this split is the seam most likely to regress.
+export function splitExecArgs(argv) {
+    const i = argv.findIndex((a, idx) => a === 'compute' && argv[idx + 1] === 'exec');
+    if (i === -1)
+        return { argv };
+    const dash = argv.indexOf('--', i + 2);
+    if (dash === -1)
+        return { argv };
+    return { argv: argv.slice(0, dash), command: argv.slice(dash + 1) };
+}
+// The --timeout override, through a throwing parser like every other user-typed number in this
+// repo (parseCpu, parseCount, parsePort): junk must fail locally instead of reaching the server as
+// NaN, and the bounds mirror what the platform enforces (1-180s; server default 30 when omitted).
+export function parseTimeoutSec(raw) {
+    const n = Number(raw);
+    if (!Number.isInteger(n) || n < 1 || n > 180)
+        throw new Error(`invalid timeout: ${raw} (1-180 seconds)`);
+    return n;
+}
+// Map exec inputs to the platform POST body. Pure, unit-tested without a network mock (mirrors
+// deployRequestBody / servicesAddRequestBody). timeoutSec is omitted when not given so the server
+// applies its own default (30s) rather than the client picking one on the wire.
+export function execRequestBody(command, timeoutSec) {
+    return { command, ...(timeoutSec !== undefined ? { timeoutSec } : {}) };
+}
+// Renders the exec response and sets process.exitCode — split out of computeExec as a pure function
+// of (res, json) so it's unit-testable without a network mock, same as handleApproval's own
+// {status, body} shape.
+//
+// A 202 means the command has NOT run: handleApproval owns the whole contract (hint on stderr,
+// raw envelope on stdout with --json, exit 2), so a caller chaining `insta compute exec … && next`
+// can never mistake a pending gate for the command having succeeded — and exit 2 stays
+// distinguishable from the remote command's own exit 1.
+export function applyExecResult(res, json) {
+    if (handleApproval(res, json))
+        return;
+    const { exitCode, stdout, stderr, truncated } = res.body;
+    if (json) {
+        printJson(res.body);
+    }
+    else {
+        process.stdout.write(stdout);
+        process.stderr.write(stderr);
+        if (truncated)
+            process.stderr.write('note: output truncated — the platform caps stdout/stderr at 1 MiB each\n');
+    }
+    // The platform sends -1 as an "unknown exit" sentinel, and nothing outside 0-255 is a valid POSIX
+    // exit code. Assigning it straight to process.exitCode risks Node's own DEP0164 (a negative code
+    // silently exits 255) — clamp out-of-range codes to 1 instead, with a one-line note so the cause is
+    // 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;
+    }
+    else {
+        process.exitCode = exitCode;
+    }
+}
+// One HTTP round trip, not a shell session: no PTY, no interactivity, stdout/stderr come back as
+// two whole strings (each capped at 1 MiB server-side) rather than a stream. They're written to
+// this process's own stdout/stderr verbatim — no prefixes, no added newline — and the remote exit
+// code becomes this process's own exit code (--json still passes it through, it just skips the
+// split-stream output), since agents scripting this rely on it. Waking a scaled-to-zero machine is
+// expected — it adds latency and bills as uptime, it is not an error.
+export async function computeExec(serviceName, command, opts) {
+    if (!command || command.length === 0)
+        throw new Error('usage: insta compute exec [service] -- <command> [args…] (see --help)');
+    const timeoutSec = opts.timeout !== undefined ? parseTimeoutSec(opts.timeout) : undefined;
+    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);
+    const res = await api.rawRequest('POST', `/projects/${p.projectId}/services/${id}/exec`, execRequestBody(command, timeoutSec));
+    applyExecResult(res, opts.json);
+}
 // ---- always-on (opt out of scale-to-zero; all plans; billing is actual usage either way) ----
 export async function computeAlwaysOn(mode, serviceName, opts) {
     if (mode !== 'on' && mode !== 'off')
@@ -80,7 +171,7 @@ export async function computeAlwaysOn(mode, serviceName, opts) {
     const { services } = await api.request('GET', `/projects/${p.projectId}/services${q(branch)}`);
     const id = resolveComputeServiceId(services, serviceName);
     const res = await api.rawRequest('PUT', `/projects/${p.projectId}/services/${id}/always-on`, { enabled: mode === 'on' });
-    if (handleApproval(res))
+    if (handleApproval(res, opts.json))
         return;
     if (opts.json)
         return printJson(res.body);
@@ -181,7 +272,7 @@ export async function computeVolume(serviceName, opts) {
         catch (e) {
             throw volumeDeleteError(e);
         }
-        if (handleApproval(res))
+        if (handleApproval(res, opts.json))
             return;
         if (opts.json)
             return printJson(res.body);
@@ -198,7 +289,7 @@ export async function computeVolume(serviceName, opts) {
     }
     const sizeGib = parseVolumeGib(opts.size);
     const res = await api.rawRequest('PUT', `/projects/${p.projectId}/services/${id}/volume`, { sizeGib });
-    if (handleApproval(res))
+    if (handleApproval(res, opts.json))
         return;
     if (opts.json)
         return printJson(res.body);
@@ -227,7 +318,7 @@ export async function computeLimits(serviceName, opts) {
     if (opts.cpu)
         body.cpu = parseCpu(opts.cpu);
     const res = await api.rawRequest('PUT', `/projects/${p.projectId}/services/${id}/limits`, body);
-    if (handleApproval(res))
+    if (handleApproval(res, opts.json))
         return;
     if (opts.json)
         return printJson(res.body);

package/dist/commands/db.js

@@ -19,7 +19,7 @@ export async function dbAlwaysOn(mode, opts) {
     if (opts.group)
         qs.set('group', opts.group);
     const res = await api.rawRequest('PATCH', `/projects/${p.projectId}/database/settings${qs.toString() ? `?${qs}` : ''}`, { scaleToZero: mode !== 'on' });
-    if (handleApproval(res))
+    if (handleApproval(res, opts.json))
         return;
     if (opts.json)
         return printJson(res.body);
@@ -111,7 +111,7 @@ export async function dbLimits(opts) {
             throw new Error(`setting the ceiling failed (${e.status}): ${e.message}`);
         throw e;
     }
-    if (handleApproval(res))
+    if (handleApproval(res, opts.json))
         return;
     if (opts.json)
         return printJson(res.body);
@@ -230,7 +230,7 @@ export async function dbVolume(opts) {
             throw new Error(`growing the volume failed (${e.status}): ${e.message}`);
         throw e;
     }
-    if (handleApproval(res))
+    if (handleApproval(res, opts.json))
         return;
     if (opts.json)
         return printJson(res.body);