insta 0.0.36 → 0.0.37

package/dist/commands/secrets.js

@@ -12,7 +12,7 @@ export async function secrets(opts) {
     const p = await requireProject();
     const branch = opts.branch ?? p.branch;
     const res = await api.rawRequest('GET', `/projects/${p.projectId}/secrets${q(branch)}`);
-    if (handleApproval(res))
+    if (handleApproval(res, opts.json))
         return;
     const bundle = res.body.secrets;
     if (opts.json)
@@ -47,7 +47,7 @@ export async function secretsTree(opts) {
     const api = await ApiClient.load();
     const p = await requireProject();
     const res = await api.rawRequest('GET', `/projects/${p.projectId}/secrets/tree`);
-    if (handleApproval(res))
+    if (handleApproval(res, opts.json))
         return;
     const tree = res.body;
     if (opts.json)
@@ -68,7 +68,7 @@ export async function secretsList(opts) {
     const p = await requireProject();
     const branch = opts.branch ?? p.branch;
     const res = await api.rawRequest('GET', `/projects/${p.projectId}/secrets/tree`);
-    if (handleApproval(res))
+    if (handleApproval(res, opts.json))
         return;
     const tree = res.body;
     const b = tree.branches.find((x) => x.name === branch);
@@ -102,8 +102,10 @@ export async function secretsSet(name, value, opts) {
     const branch = opts.service ? (opts.branch ?? p.branch) : opts.branch;
     const payload = { value: v, ...(branch ? { branch } : {}), ...(opts.service ? { service: opts.service } : {}) };
     const res = await api.rawRequest('PUT', `/projects/${p.projectId}/secrets/${encodeURIComponent(name)}`, payload);
-    if (handleApproval(res))
+    if (handleApproval(res, opts.json))
         return;
+    if (opts.json)
+        return printJson({ ok: true, name, branch: branch ?? null, service: opts.service ?? null });
     info(`set ${name}${opts.service ? ` → ${opts.service}` : ''} (${branch ? `branch ${branch}` : 'project-wide'})`);
 }
 export async function secretsUnset(name, opts) {
@@ -111,8 +113,10 @@ export async function secretsUnset(name, opts) {
     const p = await requireProject();
     const qs = opts.branch ? `?branch=${encodeURIComponent(opts.branch)}` : '';
     const res = await api.rawRequest('DELETE', `/projects/${p.projectId}/secrets/${encodeURIComponent(name)}${qs}`);
-    if (handleApproval(res))
+    if (handleApproval(res, opts.json))
         return;
+    if (opts.json)
+        return printJson({ ok: true, name, branch: opts.branch ?? null });
     info(`unset ${name} (${opts.branch ? `branch ${opts.branch}` : 'project-wide'})`);
 }
 export async function secretsBind(envName, source, opts) {
@@ -127,7 +131,7 @@ export async function secretsBind(envName, source, opts) {
         source,
         ...(opts.sourceName ? { sourceName: opts.sourceName } : {}),
     });
-    if (handleApproval(res))
+    if (handleApproval(res, opts.json))
         return;
     if (opts.json)
         return printJson({ ok: true });
@@ -140,7 +144,7 @@ export async function secretsUnbind(envName, opts) {
     const p = await requireProject();
     const branch = opts.branch ?? p.branch;
     const res = await api.rawRequest('DELETE', `/projects/${p.projectId}/secret-bindings/${encodeURIComponent(envName)}?branch=${encodeURIComponent(branch)}&target=${encodeURIComponent(opts.from)}`);
-    if (handleApproval(res))
+    if (handleApproval(res, opts.json))
         return;
     if (opts.json)
         return printJson({ ok: true });
@@ -153,7 +157,7 @@ export async function secretsBindings(opts) {
     const p = await requireProject();
     const branch = opts.branch ?? p.branch;
     const res = await api.rawRequest('GET', `/projects/${p.projectId}/secret-bindings?branch=${encodeURIComponent(branch)}&target=${encodeURIComponent(opts.target)}`);
-    if (handleApproval(res))
+    if (handleApproval(res, opts.json))
         return;
     const bindings = res.body.bindings ?? [];
     if (opts.json)
@@ -168,7 +172,7 @@ export async function secretsSources(opts) {
     const p = await requireProject();
     const branch = opts.branch ?? p.branch;
     const res = await api.rawRequest('GET', `/projects/${p.projectId}/secret-sources?branch=${encodeURIComponent(branch)}`);
-    if (handleApproval(res))
+    if (handleApproval(res, opts.json))
         return;
     const sources = res.body.sources ?? [];
     if (opts.json)

package/dist/commands/services.js

@@ -111,7 +111,7 @@ export async function servicesAdd(type, name, opts = {}) {
     const p = await requireProject();
     const branch = opts.branch ?? p.branch;
     const res = await api.rawRequest('POST', `/projects/${p.projectId}/services`, servicesAddRequestBody(type, name, branch, opts));
-    if (handleApproval(res))
+    if (handleApproval(res, opts.json))
         return;
     if (opts.json)
         return printJson(res.body.service);
@@ -151,8 +151,10 @@ export async function servicesRemove(type, name, opts = {}) {
     const { services } = await api.request('GET', `/projects/${p.projectId}/services${q(branch)}`);
     const id = resolveServiceId(services, type, name);
     const res = await api.rawRequest('DELETE', `/projects/${p.projectId}/services/${id}`);
-    if (handleApproval(res))
+    if (handleApproval(res, opts.json))
         return;
+    if (opts.json)
+        return printJson({ ok: true, removed: { id, type, name, branch: branch ?? null } });
     info(`removed ${type} service ${name} from ${branch ?? 'default'}`);
 }
 export async function servicesRename(type, name, newName, opts = {}) {
@@ -164,7 +166,7 @@ export async function servicesRename(type, name, newName, opts = {}) {
     const { services } = await api.request('GET', `/projects/${p.projectId}/services${q(branch)}`);
     const id = resolveServiceId(services, type, name);
     const res = await api.rawRequest('POST', `/projects/${p.projectId}/services/${id}/rename`, { name: newName });
-    if (handleApproval(res))
+    if (handleApproval(res, opts.json))
         return;
     if (opts.json)
         return printJson(res.body.service);
@@ -187,7 +189,7 @@ export async function servicesSetAccess(type, name, access, _opts) {
     const { services } = await api.request('GET', `/projects/${p.projectId}/services${q(p.branch)}`);
     const id = resolveServiceId(services, type, name);
     const res = await api.rawRequest('PUT', `/projects/${p.projectId}/services/${id}/access`, { public: isPublic });
-    if (handleApproval(res))
+    if (handleApproval(res, _opts.json))
         return;
     if (_opts.json)
         return printJson(res.body.service);
@@ -202,7 +204,7 @@ export async function servicesScale(type, name, number, region, _opts) {
     const { services } = await api.request('GET', `/projects/${p.projectId}/services${q(_opts.branch ?? p.branch)}`);
     const id = resolveServiceId(services, type, name);
     const res = await api.rawRequest('POST', `/projects/${p.projectId}/services/${id}/scale`, { machineCount, region });
-    if (handleApproval(res))
+    if (handleApproval(res, _opts.json))
         return;
     if (_opts.json)
         return printJson(res.body.service);
@@ -216,7 +218,7 @@ export async function servicesUpgrade(type, name, spec, _opts) {
     const { services } = await api.request('GET', `/projects/${p.projectId}/services${q(_opts.branch ?? p.branch)}`);
     const id = resolveServiceId(services, type, name);
     const res = await api.rawRequest('POST', `/projects/${p.projectId}/services/${id}/upgrade`, { spec });
-    if (handleApproval(res))
+    if (handleApproval(res, _opts.json))
         return;
     if (_opts.json)
         return printJson(res.body.service);
@@ -230,7 +232,7 @@ export async function servicesSecrets(type, name, opts = {}) {
     const { services } = await api.request('GET', `/projects/${p.projectId}/services${q(opts.branch ?? p.branch)}`);
     const id = resolveServiceId(services, type, name);
     const res = await api.rawRequest('GET', `/projects/${p.projectId}/services/${id}/secrets`);
-    if (handleApproval(res))
+    if (handleApproval(res, opts.json))
         return;
     const { secrets } = res.body;
     if (opts.json)

package/dist/commands/setup.js

@@ -6,12 +6,15 @@
 // Stack skills (tigris/better-auth) intentionally stay per-project: their presence in a
 // project doubles as its stack manifest — that install happens on `project create|link`.
 import { spawn } from 'node:child_process';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { dirname, join } from 'node:path';
 import os from 'node:os';
 import { ApiClient } from '../api.js';
 import { resolveEnv } from '../config.js';
 import { DEFAULT_ENV, ENVS, mcpServerName } from '../env.js';
 import { info } from '../util.js';
 import { installAgentConfigs } from './mcp.js';
+import { detectChannel } from './upgrade.js';
 // The `skills` tool we shell out to prints a clack UI: a frame-by-frame clone spinner, an
 // "Installing to all N agents" banner, a full N-line install-path box, and a third-party
 // "Security Risk Assessment" that flags our OWN first-party skill as "Critical Risk". Streamed
@@ -76,13 +79,165 @@ export function summarizeInstall(output) {
         : `${count} agent${count === 1 ? '' : 's'}`;
     return `✓ Agent skills — ${list}`;
 }
+// ---- CLI self-install (makes `npx -y insta setup agent` a complete one-liner) ----
+// Under npx the CLI runs from the npm cache and vanishes when the process exits — but the skill
+// installed below tells every agent to run `insta …`, which then wouldn't exist. So when this
+// process came from the npm channel and no DURABLE `insta` is on PATH, install ourselves
+// globally first. The scan must ignore any PATH entry under a node_modules directory: npx
+// prepends its cache's node_modules/.bin (where this very process's `insta` shim lives), while
+// durable installs (npm -g bin, nvm/volta/fnm, the native binary's ~/.insta/bin) never sit
+// under one.
+// On POSIX a PATH hit only counts if it would actually run: a plain non-executable file (or a
+// directory) named `insta` must not suppress the self-install. Mode bits, not access(X_OK) —
+// access() answers "can THIS process exec it", which for root is always yes, so a root-run
+// setup would wrongly treat a non-executable file as a durable install. On Windows execute
+// permission is extension-driven, so existence of a regular file is the right check.
+const isRunnableFile = (p, win) => {
+    try {
+        const st = statSync(p);
+        if (!st.isFile())
+            return false;
+        return win || (st.mode & 0o111) !== 0;
+    }
+    catch {
+        return false;
+    }
+};
+/** 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 handing it a bare
+ *  `claude` would let a claude.cmd planted in the project directory shadow the real CLI —
+ *  the cmd.exe wrapper below only ever passes absolute paths. */
+export function whichOnPath(bin, env = process.env, platform = process.platform) {
+    const win = platform === 'win32';
+    const exts = win ? [...(env.PATHEXT ?? '.COM;.EXE;.BAT;.CMD').split(';'), ''] : [''];
+    for (const dir of (env.PATH ?? '').split(win ? ';' : ':')) {
+        if (!dir)
+            continue;
+        for (const ext of exts) {
+            const p = join(dir, bin + ext);
+            if (isRunnableFile(p, win))
+                return p;
+        }
+    }
+    return null;
+}
+export function findDurableOnPath(bin, env = process.env, platform = process.platform) {
+    const win = platform === 'win32';
+    const dirs = (env.PATH ?? '').split(win ? ';' : ':');
+    // npm on Windows writes insta.cmd/insta.ps1 plus an extensionless sh shim; PATHEXT covers the
+    // former, the bare name the latter.
+    const exts = win ? [...(env.PATHEXT ?? '.COM;.EXE;.BAT;.CMD').split(';'), ''] : [''];
+    for (const dir of dirs) {
+        // Case-insensitive: Windows paths (and the npx cache) may carry any casing.
+        if (!dir || dir.toLowerCase().includes('node_modules'))
+            continue;
+        for (const ext of exts)
+            if (isRunnableFile(join(dir, bin + ext), win))
+                return true;
+    }
+    return false;
+}
+const cliVersion = () => {
+    try {
+        return JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8')).version;
+    }
+    catch {
+        return 'latest';
+    }
+};
+/** Best-effort: a failed global install must not block the skill/MCP setup below — the npx run
+ *  itself still completes the agent onboarding, and the manual fallback is one line. */
+export async function ensureCliInstalled(run, channel = detectChannel(), onPath = findDurableOnPath('insta'), recheck = () => findDurableOnPath('insta')) {
+    if (channel !== 'npm' || onPath)
+        return;
+    info('installing the insta CLI globally (npm) …');
+    // Pinned to THIS version so the one-liner installs exactly what it ran. The logical `npm` is
+    // resolved to a spawnable invocation ONCE, inside the default runner (resolveSpawnable) —
+    // handing it a pre-resolved node/npm-cli.js path here would make the runner resolve it a
+    // second time and, on Windows, wrap the real node.exe in cmd.exe.
+    const spec = `insta@${cliVersion()}`;
+    const res = await run('npm', ['install', '-g', spec]);
+    if (res.ok) {
+        // A clean `npm i -g` can still land in a bin dir that isn't on PATH (custom npm prefix) —
+        // exactly the machines this path exists for. Only claim success after re-finding the shim.
+        if (recheck()) {
+            info('✓ insta CLI — installed globally (`insta` now works in any shell)');
+        }
+        else {
+            info('✓ insta CLI — installed globally, but npm\'s global bin dir is not on PATH');
+            info('    add it to PATH (POSIX: `$(npm prefix -g)/bin`; Windows: the dir `npm prefix -g` prints), then verify with `insta --version`');
+        }
+        return;
+    }
+    info('  global CLI install failed — continuing with agent setup; install manually with:');
+    info(`    npm install -g ${spec}`);
+    if (/EACCES|permission denied/i.test(res.output ?? '')) {
+        info('    (permission error: the npm prefix is system-owned — use a Node version manager, or elevate that one command)');
+    }
+}
+// ---- Windows-safe spawning for npm/npx ----
+// On Windows `npm`/`npx` are .cmd shims, which spawn() without a shell refuses (Node docs:
+// spawning .bat/.cmd needs a shell or cmd.exe). Rather than a shell (argument-quoting hazards),
+// re-enter them as node scripts: the CLI script named by npm_execpath (swapped between
+// npm-cli.js and npx-cli.js as needed), else the one shipped beside the running node, else the
+// bare name (POSIX, where PATH shims resolve fine). Applied ONCE, inside the default runner,
+// so every `run('npm'|'npx', …)` call site benefits and nothing is ever resolved twice.
+export function resolveSpawnable(cmd, args, npmExecpath = process.env.npm_execpath, execPath = process.execPath, platform = process.platform, env = process.env) {
+    // Node re-entry is only valid when THIS process runs on node. On the native-binary channel
+    // execPath is the compiled `insta` executable — and npm scripts export npm_execpath to their
+    // children — so re-entering blindly would spawn `insta npx-cli.js …`. A non-node execPath
+    // sends npm/npx down the generic shim path below instead.
+    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] };
+    }
+    // Generic shim path — every non-npm CLI we shell out to (claude), plus npm/npx themselves
+    // when node isn't resolvable (native binary channel). On Windows these are .cmd shims, which
+    // spawn() refuses without a shell, so route them through cmd.exe. Guards, in order:
+    // - BARE names only: an absolute path or anything .exe (node.exe from a resolved npm/npx
+    //   invocation passing back through here) is directly spawnable and must NOT see cmd.exe.
+    // - The name is resolved to its ABSOLUTE PATH location first: cmd.exe searches the current
+    //   directory before PATH, so a bare name would let a shim planted in the project dir
+    //   shadow the real CLI. No PATH hit → pass through (spawn fails; callers degrade).
+    // - No manual quoting: libuv already wraps spaced args when building the child command
+    //   line — pre-quoting would be quoted AGAIN and arrive as literal quote characters.
+    // - That leaves cmd.exe metacharacters unprotectable, so an arg carrying one (e.g. a
+    //   custom INSTA_MCP_URL with `&`) skips the wrapper: the bare-shim spawn fails and every
+    //   caller degrades gracefully (probe → not-installed; registration → manual-add
+    //   fallback). Never hand metacharacters to a shell.
+    const bareShim = !/[\\/]/.test(cmd) && !/\.exe$/i.test(cmd);
+    if (platform === 'win32' && bareShim && !args.some((a) => /[&|<>^%"]/.test(a))) {
+        const abs = whichOnPath(cmd, env, platform);
+        if (abs)
+            return { cmd: 'cmd.exe', args: ['/d', '/s', '/c', abs, ...args] };
+    }
+    return { cmd, args };
+}
 // Capture stdout+stderr silently (don't stream) so we can print our own clean summary.
 // stdin is 'ignore', NOT 'inherit': under the canonical `curl … | sh` install, stdin is the
 // piped install script itself — a child that inherits it (npx/skills reads for keypresses even
 // with -y) consumes the rest of the script, so the shell never runs the trailing "Get started"
 // guidance. Ignoring stdin keeps the installer's own output intact. (-y means no prompt anyway.)
-const defaultRunner = (cmd, args) => new Promise((resolve) => {
+const defaultRunner = (cmdIn, argsIn) => new Promise((resolve) => {
+    const { cmd, args } = resolveSpawnable(cmdIn, argsIn);
     const env = { ...process.env, AI_AGENT: process.env.AI_AGENT || 'insta', FORCE_COLOR: '0' };
+    // When THIS process was launched by npx, npx exports its flags as npm_config_* env vars.
+    // npm_config_package pins package resolution for every nested npm/npx child — the inner
+    // `npx -y skills …` would then resolve `skills` against the insta package and degrade to
+    // `sh: skills: command not found`. Scrub the resolution-pinning vars; keep prefix/registry
+    // (deliberate user configuration).
+    delete env.npm_config_package;
+    delete env.npm_config_call;
     const p = spawn(cmd, args, { stdio: ['ignore', 'pipe', 'pipe'], env });
     let output = '';
     const grab = (chunk) => { output += chunk.toString(); };
@@ -91,11 +246,14 @@ const defaultRunner = (cmd, args) => new Promise((resolve) => {
     p.on('error', () => resolve({ ok: false, output }));
     p.on('close', (code) => resolve({ ok: code === 0, output }));
 });
+// Leading -y is npx's OWN flag: on a machine where the `skills` package isn't already in the
+// npx cache, non-TTY `npx skills …` refuses to auto-install and degrades to a shell lookup
+// (`sh: skills: command not found`) — the trailing -y only answers the skills TOOL's prompt.
 // -g = user-level (machine-global); -a '*' = every agent dir the skills tool supports
 // (Claude Code, Codex, Cursor, OpenCode, Copilot, …); --copy = real files, not cache symlinks.
 // `spec` is the skill source for the resolved environment (`owner/repo` or `owner/repo@ref`), so a
 // staging install reads the staging skill text rather than what's published on main.
-export const setupArgs = (spec) => ['skills', 'add', spec, '-s', 'insta', '-a', '*', '-g', '-y', '--copy'];
+export const setupArgs = (spec) => ['-y', 'skills', 'add', spec, '-s', 'insta', '-a', '*', '-g', '-y', '--copy'];
 /** Production's args. Kept as a named export because it is the installed-base default and is
  *  asserted directly by tests; runtime goes through `setupArgs(resolveEnv().skills)`. */
 export const SETUP_ARGS = setupArgs(ENVS[DEFAULT_ENV].skills);
@@ -158,10 +316,13 @@ export async function registerMcp(run = defaultRunner, mint = defaultMinter, use
         info(`  MCP registration failed — add manually:\n    claude mcp add --transport http ${name} ${url}`);
     }
 }
-export async function setupAgent(opts, run = defaultRunner, mint, installConfigs = installAgentConfigs) {
+export async function setupAgent(opts, run = defaultRunner, mint, installConfigs = installAgentConfigs, ensure = (r) => ensureCliInstalled(r)) {
     if (!opts.yes && !process.stdout.isTTY) {
         info('non-interactive shell — assuming -y');
     }
+    // BEFORE the skill install: the skill tells agents to run `insta …`, so a durable CLI must
+    // exist by the time it lands.
+    await ensure(run);
     // One resolve for the whole step, so the skills and the MCP registration below cannot disagree
     // about which environment this machine belongs to.
     const { env, skills } = await resolveEnv();

package/dist/commands/storage.js

@@ -50,7 +50,7 @@ export async function storageList(opts) {
     const branch = opts.branch ?? p.branch;
     const svc = await storageTarget(api, p.projectId, branch, opts.service);
     const res = await api.rawRequest('GET', objectsPath(p.projectId, svc.id, { branch, prefix: opts.prefix, cursor: opts.cursor, limit }));
-    if (handleApproval(res))
+    if (handleApproval(res, opts.json))
         return;
     if (opts.json)
         return printJson(res.body);
@@ -143,7 +143,7 @@ export async function storageGet(key, opts, deps = {}) {
     const branch = opts.branch ?? p.branch;
     const svc = await storageTarget(api, p.projectId, branch, opts.service);
     const res = await api.rawRequest('GET', objectDownloadPath(p.projectId, svc.id, { branch, key }));
-    if (handleApproval(res))
+    if (handleApproval(res, opts.json))
         return;
     // --json hands over the presigned URL instead of downloading, as `insta secrets --json` does.
     // Before outputPath, so a key with no filename still works when nothing is written to disk.
@@ -164,7 +164,7 @@ export async function storageDelete(key, opts) {
     const branch = opts.branch ?? p.branch;
     const svc = await storageTarget(api, p.projectId, branch, opts.service);
     const res = await api.rawRequest('DELETE', objectsPath(p.projectId, svc.id, { branch, key }));
-    if (handleApproval(res))
+    if (handleApproval(res, opts.json))
         return;
     if (opts.json)
         return printJson(res.body);

package/dist/ensure-skills.js

@@ -9,6 +9,7 @@ import { spawn } from 'node:child_process';
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { resolveEnv } from './config.js';
+import { resolveSpawnable } from './commands/setup.js';
 import { DEFAULT_ENV, ENVS } from './env.js';
 // Where `npx skills add` drops skills for the agents we pin below: Claude Code → .claude/skills/,
 // Codex → .agents/skills/ (.github/skills/ is the third well-known dir). These are regenerable
@@ -20,8 +21,15 @@ const SKILL_DIRS = ['.claude/skills/', '.agents/skills/', '.github/skills/'];
 // honest here (this IS programmatic, not an interactive prompt) and, because we already pin the
 // agents/skills/-y, has no effect on the install beyond quieting the banner. Preserve a caller's
 // existing AI_AGENT (e.g. running inside another agent) rather than clobbering it.
-const defaultRunner = (cmd, args, inherit = false) => new Promise((resolve) => {
+const defaultRunner = (cmdIn, argsIn, inherit = false) => new Promise((resolve) => {
+    // resolveSpawnable: on Windows `npx` is a .cmd shim spawn() refuses without a shell —
+    // re-enter npm's CLI script via node instead (same treatment as `insta setup agent`).
+    const { cmd, args } = resolveSpawnable(cmdIn, argsIn);
     const env = { ...process.env, AI_AGENT: process.env.AI_AGENT || 'insta' };
+    // npx exports its flags as npm_config_* to children; npm_config_package would pin the inner
+    // `npx -y skills …` to whatever package launched this CLI (see setup.ts defaultRunner).
+    delete env.npm_config_package;
+    delete env.npm_config_call;
     const p = spawn(cmd, args, { stdio: inherit ? 'inherit' : 'ignore', env });
     p.on('error', () => resolve({ ok: false })); // e.g. npx not on PATH
     p.on('close', (code) => resolve({ ok: code === 0 }));
@@ -31,17 +39,21 @@ const defaultRunner = (cmd, args, inherit = false) => new Promise((resolve) => {
 // name the exact skills (-s …) so there's no skill picker; -y to skip the scope/confirm prompt;
 // --copy to write real files (not symlinks into a transient npx cache).
 const AGENT_FLAGS = ['-a', 'claude-code', '-a', 'codex', '-y', '--copy'];
+// npx's OWN -y, distinct from the skills tool's -y above: without it, a machine whose npx cache
+// lacks the `skills` package refuses the auto-install in non-TTY runs and the whole command
+// degrades to `sh: skills: command not found`.
+const NPX_YES = ['-y'];
 // `instaSpec` is the insta skill source for the resolved environment (`owner/repo[@ref]`), so a
 // project created against staging gets the staging skill text. The third-party stack skills are
 // environment-independent — they document Tigris/Better Auth, not our control plane.
 const skillTargets = (instaSpec) => [
-    { label: 'insta', args: ['skills', 'add', instaSpec, '-s', 'insta', ...AGENT_FLAGS] },
-    { label: 'tigris', args: ['skills', 'add', 'tigrisdata/skills',
+    { label: 'insta', args: [...NPX_YES, 'skills', 'add', instaSpec, '-s', 'insta', ...AGENT_FLAGS] },
+    { label: 'tigris', args: [...NPX_YES, 'skills', 'add', 'tigrisdata/skills',
             '-s', 'tigris-object-operations', '-s', 'file-storage', '-s', 'tigris-sdk-guide',
             '-s', 'tigris-security-access-control', '-s', 'tigris-image-optimization',
             '-s', 'tigris-s3-migration', '-s', 'tigris-static-assets', '-s', 'tigris-agent-kit',
             ...AGENT_FLAGS] },
-    { label: 'better-auth', args: ['skills', 'add', 'better-auth/skills',
+    { label: 'better-auth', args: [...NPX_YES, 'skills', 'add', 'better-auth/skills',
             '-s', 'better-auth-best-practices', '-s', 'email-and-password-best-practices',
             '-s', 'better-auth-security-best-practices', ...AGENT_FLAGS] },
 ];

package/dist/flyctl-build.js

@@ -4,17 +4,21 @@
 import { spawn } from 'node:child_process';
 import { existsSync, writeFileSync, unlinkSync } from 'node:fs';
 import { join } from 'node:path';
-import { info } from './util.js';
 // Spawn flyctl, tee its output to the user (so they see buildkit progress) AND capture it for digest
-// parsing.
-export const defaultBuildRunner = (cmd, args, opts) => new Promise((resolve) => {
-    const child = spawn(cmd, args, { cwd: opts.cwd, env: opts.env, stdio: ['inherit', 'pipe', 'pipe'] });
-    let output = '';
-    child.stdout?.on('data', (b) => { const s = b.toString(); output += s; process.stdout.write(s); });
-    child.stderr?.on('data', (b) => { const s = b.toString(); output += s; process.stderr.write(s); });
-    child.on('error', (err) => resolve({ code: -1, output: `${output}\n${err.message}` }));
-    child.on('close', (code) => resolve({ code: code ?? -1, output }));
-});
+// parsing. `to` picks the tee destination for the child's stdout: `deploy --json` reserves the
+// process's stdout for the final JSON document, so it tees build progress to stderr instead.
+function teeRunner(to) {
+    return (cmd, args, opts) => new Promise((resolve) => {
+        const child = spawn(cmd, args, { cwd: opts.cwd, env: opts.env, stdio: ['inherit', 'pipe', 'pipe'] });
+        let output = '';
+        child.stdout?.on('data', (b) => { const s = b.toString(); output += s; to.write(s); });
+        child.stderr?.on('data', (b) => { const s = b.toString(); output += s; process.stderr.write(s); });
+        child.on('error', (err) => resolve({ code: -1, output: `${output}\n${err.message}` }));
+        child.on('close', (code) => resolve({ code: code ?? -1, output }));
+    });
+}
+export const defaultBuildRunner = teeRunner(process.stdout);
+export const stderrBuildRunner = teeRunner(process.stderr);
 // buildkit prints "pushing manifest for registry.fly.io/<app>:<label>@sha256:<digest>" on push.
 // Pin to the digest — the bare tag races on Fly's registry (MANIFEST_UNKNOWN); the digest always resolves.
 export function parseImageDigest(output, flyApp) {
@@ -57,10 +61,13 @@ export async function flyctlBuildAndPush(opts, run = defaultBuildRunner) {
     }
 }
 // Best-effort: ensure the fly CLI is available (needed for source-directory deploys). Never blocks —
-// if it can't be installed the subsequent build surfaces a clear error.
+// if it can't be installed the subsequent build surfaces a clear error. Everything here is one-time
+// bootstrap DIAGNOSTICS, so it all goes to stderr — including the installers' own stdout (fd 2 in
+// the stdio triple) — keeping stdout clean for `deploy --json`.
 export async function ensureFlyctl() {
+    const note = (m) => process.stderr.write(m + '\n');
     const ok = (cmd, args, inherit = false) => new Promise((resolve) => {
-        const p = spawn(cmd, args, { stdio: inherit ? 'inherit' : 'ignore' });
+        const p = spawn(cmd, args, { stdio: inherit ? ['inherit', 2, 2] : 'ignore' });
         p.on('error', () => resolve(false));
         p.on('close', (code) => resolve(code === 0));
     });
@@ -68,8 +75,8 @@ export async function ensureFlyctl() {
         if (await ok('flyctl', ['version']))
             return;
         if (process.platform === 'darwin' && (await ok('brew', ['--version']))) {
-            info('flyctl not found — installing with `brew install flyctl` (one-time)…');
-            info((await ok('brew', ['install', 'flyctl'], true)) ? 'flyctl installed ✓' : 'flyctl install failed — install manually: https://fly.io/docs/flyctl/install/');
+            note('flyctl not found — installing with `brew install flyctl` (one-time)…');
+            note((await ok('brew', ['install', 'flyctl'], true)) ? 'flyctl installed ✓' : 'flyctl install failed — install manually: https://fly.io/docs/flyctl/install/');
             return;
         }
         if (process.platform === 'linux') {
@@ -77,20 +84,20 @@ export async function ensureFlyctl() {
             // and no brew; without this branch `insta deploy <dir>` dead-ends on a hand-install of a
             // third-party CLI. Official installer, pinned into ~/.fly; the current process extends its
             // own PATH because the installer's shell-profile edit can't reach an already-running process.
-            info('flyctl not found — installing to ~/.fly (one-time)…');
+            note('flyctl not found — installing to ~/.fly (one-time)…');
             const flyHome = `${process.env.HOME ?? '~'}/.fly`;
             const installed = await ok('sh', ['-c', `curl -fsSL https://fly.io/install.sh | FLYCTL_INSTALL="${flyHome}" sh`], true);
             if (installed) {
                 process.env.PATH = `${process.env.PATH}:${flyHome}/bin`;
                 if (await ok('flyctl', ['version'])) {
-                    info('flyctl installed ✓');
+                    note('flyctl installed ✓');
                     return;
                 }
             }
-            info('flyctl install failed — install manually: https://fly.io/docs/flyctl/install/');
+            note('flyctl install failed — install manually: https://fly.io/docs/flyctl/install/');
             return;
         }
-        info('flyctl (fly CLI) not found — install it to deploy from source: https://fly.io/docs/flyctl/install/');
+        note('flyctl (fly CLI) not found — install it to deploy from source: https://fly.io/docs/flyctl/install/');
     }
     catch { /* best-effort convenience */ }
 }