insta 0.0.47 → 0.0.49

package/dist/index.js

@@ -2,7 +2,7 @@
 import { readFileSync } from 'node:fs';
 import { Command } from 'commander';
 import { ApiError } from './api.js';
-import { die } from './util.js';
+import { CliExit, fail } from './util.js';
 import * as auth from './commands/auth.js';
 import * as envCmd_ from './commands/env.js';
 import { ENV_NAMES } from './env.js';
@@ -30,9 +30,11 @@ 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)
+        return;
     if (e instanceof ApiError)
-        die(`${e.message} (HTTP ${e.status})`);
-    die(e instanceof Error ? e.message : String(e));
+        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);
@@ -87,6 +89,7 @@ setupCmd.command('agent').description('Install the insta CLI (if missing), the i
     .option('-y, --yes', 'non-interactive')
     .option('--env <prod|staging>', 'deployment to set this machine up for (default: prod — switches and persists, like `insta env use`)')
     .option('--mcp-token', 'register the MCP server with a minted insta_ API token instead of OAuth (headless machines / CI)')
+    .option('--project <id>', 'also link this directory to an existing project after setup (flows through login first if needed)')
     .action(guard((o) => setup.setupAgent(o)));
 // ---- MCP server integration ----
 const mcpCmd = program.command('mcp').description('insta-cloud remote MCP server integration');
@@ -179,7 +182,7 @@ sec.command('sources').description('List service credential sources available fo
 sec.command('tree').description('Show secrets as project → branch → service → secrets').option('--json')
     .action(guard((o) => secretsCmd.secretsTree(o)));
 // ---- build (pre-push verification — local, offline, deploys nothing) ----
-program.command('build [dir]').description('Verify a source directory would build before deploying: detection plan + the Dockerfile that would be used (yours, or nixpacks-generated) + static checks. Local and offline — no login needed, nothing pushed. Exit 1 when the verdict is failed')
+program.command('build [dir]').description('Verify a source directory would build before deploying: detection plan + the Dockerfile (yours, or the one nixpacks would generate for the GitHub lane — `insta deploy <dir>` needs your own) + static checks. Local and offline — no login needed, nothing pushed. Exit 1 when the verdict is failed')
     .option('--explain', 'include the Dockerfile content in the output')
     .option('--port <p>', 'port the app listens on (else the Dockerfile EXPOSE)')
     .option('--json')
@@ -193,7 +196,7 @@ program.command('deploy [dir]').description('Deploy a source directory (built re
 // `insta compute exec` needs the command verbatim after a literal `--`; split it out of argv here,
 // before commander parses anything (see splitExecArgs's own comment for why `service` being
 // optional makes commander unable to hold that boundary itself).
-const { argv: computeArgv, command: execCommand } = computeCmd.splitExecArgs(process.argv);
+const { argv: computeArgv, command: execCommand, windowsFallback: execWindowsFallback, } = computeCmd.splitExecArgs(process.argv);
 // ---- compute (lifecycle control + custom domains) ----
 const compute = program.command('compute').description('Control compute lifecycle (start/stop/suspend/status) + custom domains');
 compute.command('set-domain <host>').description('Attach a custom domain to a branch compute service (gated: deploy)')
@@ -215,9 +218,12 @@ compute.command('limits [service]').description("Show or set a compute service's
     .option('--json').option('--branch <branch>', 'branch (default: current)').action(guard((service, o) => computeCmd.computeLimits(service, o)));
 compute.command('always-on <mode> [service]').description('Set a compute service always-on (mode: on|off). on = machines never scale to zero; off = default scale-to-zero. All plans; billing is actual usage either way')
     .option('--json').option('--branch <branch>', 'branch (default: current)').action(guard((mode, service, o) => computeCmd.computeAlwaysOn(mode, service, o)));
-compute.command('exec [service]').description("Run a one-shot command inside a compute service's machine (`insta compute exec [service] -- <command> [args…]`) — no interactive shell/PTY: `command` is argv, no shell is invoked (use [\"sh\", \"-c\", \"...\"] for shell features). Wakes the machine first if it's scaled to zero — expect a few seconds of latency, billed as uptime, not an error. Exits with the remote command's own exit code (agents rely on this)")
-    .option('--branch <b>').option('--timeout <sec>', 'command timeout in seconds, 1-180 (platform default: 30)').option('--json')
-    .action(guard((service, o) => computeCmd.computeExec(service, execCommand, o)));
+const execCmd = compute.command('exec [service]').description("Run a one-shot command inside a compute service's machine (`insta compute exec [service] -- <command> [args…]`) — no interactive shell/PTY: `command` is argv, no shell is invoked (use [\"sh\", \"-c\", \"...\"] for shell features). Wakes the machine first if it's scaled to zero — expect a few seconds of latency, billed as uptime, not an error. Exits with the remote command's own exit code (agents rely on this)")
+    .action(guard((service, o) => computeCmd.computeExec(service, execCommand, o, { windowsFallback: execWindowsFallback })));
+// Declared from the same list splitExecArgs uses to find where the CLI's own arguments stop, so a
+// new option cannot reach the CLI surface while the split still reads it as part of the command.
+for (const [flags, description] of computeCmd.EXEC_OPTIONS)
+    execCmd.option(flags, description);
 compute.command('volume [service]').description("Show, attach, grow, or delete a compute service's persistent /data volume. No flag: print size, mount path, and the plan cap (any plan). --size on a volumeless service ATTACHES one (any plan at the default 1Gi; larger is paid and plan-capped; the disk mounts at /data on the next deploy); on a volume-bearing one it grows (paid plans; grow-only — a provisioned disk cannot shrink). --delete DESTROYS the disk and ALL its data immediately (no detach, no undo; billing stops now, and suspend fast-wake + scale-out return). Billing is actual data stored — the size is a cap, not a price")
     .option('--size <gi>', 'new size in whole Gi, e.g. 10 (must be ≥ the current size)')
     .option('--delete', 'destroy the volume and ALL its data (irreversible; download anything you need first)')
@@ -336,10 +342,10 @@ program.command('feedback')
     .action(guard((o) => feedbackCmd.feedback(o)));
 // ---- self-update ----
 program.command('upgrade').description('Update the insta CLI to the latest release (binary or npm install)')
-    .action(guard(() => selfUpdate.upgrade()));
+    .action(guard(() => selfUpdate.upgrade(resolveVersion())));
 program.command('autoupdate [mode]').description('Show or set auto-update: on | off (default: on while pre-1.0)')
     .action(guard((mode) => selfUpdate.autoupdate(mode)));
-program.command('__update-check', { hidden: true }).action(guard(() => selfUpdate.backgroundCheck()));
+program.command('__update-check', { hidden: true }).action(guard(() => selfUpdate.backgroundCheck(resolveVersion())));
 selfUpdate.maybeUpdate(resolveVersion(), process.argv);
 program.parseAsync(computeArgv);
 //# sourceMappingURL=index.js.map

package/dist/spawn.js

@@ -0,0 +1,77 @@
+import { existsSync, statSync } from 'node:fs';
+import { dirname, join, win32 } from 'node:path';
+export const isRunnableFile = (path, win) => {
+    try {
+        const stat = statSync(path);
+        if (!stat.isFile())
+            return false;
+        return win || (stat.mode & 0o111) !== 0;
+    }
+    catch {
+        return false;
+    }
+};
+/** Read an environment variable the way Windows itself does: case-insensitively.
+ *  `process.env` is already case-insensitive on win32, but a COPY of it (`{ ...process.env }`,
+ *  which every caller that adds a variable makes) is an ordinary object that keeps whatever
+ *  casing Windows used — and Windows overwhelmingly spells it `Path`, not `PATH`. Reading
+ *  `env.PATH` off such a copy yields undefined, nothing resolves, and the caller falls back to
+ *  spawning the bare `.cmd` shim this module exists to avoid. */
+export function envVar(env, name, win) {
+    const direct = env[name];
+    if (direct !== undefined || !win)
+        return direct;
+    const wanted = name.toLowerCase();
+    for (const [key, value] of Object.entries(env))
+        if (key.toLowerCase() === wanted)
+            return value;
+    return undefined;
+}
+/** Resolve a bare command name to its absolute PATH location (PATHEXT-aware on Windows).
+ *  cmd.exe searches the CURRENT DIRECTORY before PATH for bare names, so callers must pass
+ *  the absolute shim path to the cmd.exe wrapper below. */
+export function whichOnPath(bin, env = process.env, platform = process.platform) {
+    const win = platform === 'win32';
+    const exts = win ? [...(envVar(env, 'PATHEXT', win) ?? '.COM;.EXE;.BAT;.CMD').split(';'), ''] : [''];
+    for (const dir of (envVar(env, 'PATH', win) ?? '').split(win ? ';' : ':')) {
+        if (!dir)
+            continue;
+        for (const ext of exts) {
+            const path = join(dir, bin + ext);
+            if (isRunnableFile(path, win))
+                return path;
+        }
+    }
+    return null;
+}
+// On Windows `npm`/`npx` and most npm-installed CLIs are .cmd shims, which spawn() without a
+// shell refuses. Prefer re-entering npm/npx through node; otherwise resolve a safe absolute shim
+// path and invoke it through cmd.exe. Kept shared so every child-process call uses the same rules.
+export function resolveSpawnable(cmd, args, npmExecpath = process.env.npm_execpath, execPath = process.execPath, platform = process.platform, env = process.env, systemRoot = process.env.SYSTEMROOT ?? process.env.windir ?? 'C:\\Windows') {
+    const execIsNode = /(^|[\\/])node(\.exe)?$/i.test(execPath);
+    if ((cmd === 'npm' || cmd === 'npx') && execIsNode) {
+        if (npmExecpath && /(^|[\\/])np[mx](-cli)?\.[cm]?js$/.test(npmExecpath)) {
+            const cli = npmExecpath.replace(/np[mx](-cli)?(\.[cm]?js)$/, `${cmd}$1$2`);
+            if (existsSync(cli))
+                return { cmd: execPath, args: [cli, ...args] };
+        }
+        const nodeDir = dirname(execPath);
+        const besideNode = platform === 'win32'
+            ? join(nodeDir, 'node_modules', 'npm', 'bin', `${cmd}-cli.js`)
+            : join(nodeDir, '..', 'lib', 'node_modules', 'npm', 'bin', `${cmd}-cli.js`);
+        if (existsSync(besideNode))
+            return { cmd: execPath, args: [besideNode, ...args] };
+    }
+    const bareShim = !/[\\/]/.test(cmd) && !/\.exe$/i.test(cmd);
+    if (platform === 'win32' && bareShim && !args.some((arg) => /[&|<>^%"]/.test(arg))) {
+        const absolute = whichOnPath(cmd, env, platform);
+        // The resolved path itself also becomes cmd.exe input. If a PATH directory contains a shell
+        // metacharacter, fail via the caller's normal bare-spawn fallback rather than interpret it.
+        // Pin cmd.exe to System32 too: CreateProcess-style lookup checks cwd before PATH.
+        if (absolute && !/[&|<>^%"]/.test(absolute)) {
+            return { cmd: win32.join(systemRoot, 'System32', 'cmd.exe'), args: ['/d', '/s', '/c', absolute, ...args] };
+        }
+    }
+    return { cmd, args };
+}
+//# sourceMappingURL=spawn.js.map

package/dist/util.js

@@ -48,9 +48,24 @@ export function openUrl(url) {
         return false;
     }
 }
-export function die(msg) {
+export class CliExit extends Error {
+    constructor() {
+        // Preserve the observable error used by direct command-unit tests that previously mocked
+        // process.exit(1) by throwing `Error('exit 1')`.
+        super('exit 1');
+        this.name = 'CliExit';
+    }
+}
+export function fail(msg) {
     process.stderr.write(`error: ${msg}\n`);
-    process.exit(1);
+    process.exitCode = 1;
+}
+// Stop the current command without forcing Node to tear down active libuv handles. On Windows,
+// process.exit() can race the detached update-check child and abort in src\win\async.c with
+// UV_HANDLE_CLOSING. The guard absorbs CliExit after fail() records the intended exit status.
+export function die(msg) {
+    fail(msg);
+    throw new CliExit();
 }
 export function printJson(v) {
     process.stdout.write(JSON.stringify(v, null, 2) + '\n');

package/package.json

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