insta 0.0.37 → 0.0.38

package/README.md

@@ -29,13 +29,21 @@ For coding agents. Installs the CLI, the `insta` skill for every agent on the ma
 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:
+version-pinned `npm install -g` fallback to run yourself). E2e-validated on macOS, Linux,
+and Windows (PowerShell + cmd):
 
 ```bash
 npx -y insta setup agent
 ```
 
+This command means **production** (CLI ≥ 0.0.38): if the machine was previously switched to
+staging it switches back — announced, session dropped, like `insta env use prod`. Staging is
+its own explicit command, which also persists the choice:
+
+```bash
+npx -y insta setup agent --env staging
+```
+
 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
@@ -179,7 +187,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 CLI (if missing), the skill, and MCP for every coding agent |
+| `insta setup` | `agent` — install the CLI (if missing), the skill, and MCP for every coding agent; targets prod, `--env staging` for staging |
 | `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/commands/env.js

@@ -73,8 +73,8 @@ export async function envUse(name, opts = {}) {
         info('  previous session dropped (separate deployment) — run `insta login --oauth github`');
     // Switching the CLI does NOT re-point already-installed agents: their MCP registration and skill
     // files were written for the previous environment and are keyed by a different server name, so
-    // they keep talking to it until setup is re-run. (The installer path is fine — install.sh runs
-    // `env use` before `setup agent`.)
-    info('  re-point this machine\'s agents at it with: insta setup agent');
+    // they keep talking to it until setup is re-run. --env is REQUIRED in the hint: since 0.0.38 a
+    // bare `setup agent` forces prod, which would silently undo the switch the user just made.
+    info(`  re-point this machine's agents at it with: insta setup agent --env ${target}`);
 }
 //# sourceMappingURL=env.js.map

package/dist/commands/feedback.js

@@ -37,7 +37,10 @@ export const LIMITS = {
 const FEEDBACK_ENDPOINT = process.env.INSTA_FEEDBACK_URL ||
     'https://feedback.instacloud.com/v1/feedback';
 const FEEDBACK_INGEST_TOKEN = process.env.INSTA_FEEDBACK_TOKEN || 'insta-feedback-public-v1';
-const FEEDBACK_TIMEOUT_MS = 10_000;
+// 15s gives the backend's scale-to-zero cold start room to answer (the ingest service waits out
+// the DB wake and persists, so a report can land after the old 10s deadline gave up on it).
+// An expired deadline is reported as UNCONFIRMED, not failed — the report may well be stored.
+const FEEDBACK_TIMEOUT_MS = 15_000;
 const MAX_FILE_BYTES = 256 * 1024;
 function resolveCliVersion() {
     // Same resolution as index.ts: the standalone binary bakes INSTA_CLI_VERSION via --define;
@@ -178,8 +181,10 @@ export async function submit(payload, fetchImpl) {
         });
     }
     catch (e) {
-        const timedOut = e instanceof Error && e.name === 'TimeoutError';
-        return { status: 'error', error: timedOut ? `timed out after ${FEEDBACK_TIMEOUT_MS / 1000}s` : `network error: ${e instanceof Error ? e.message : String(e)}` };
+        if (e instanceof Error && e.name === 'TimeoutError') {
+            return { status: 'unconfirmed', error: `no response after ${FEEDBACK_TIMEOUT_MS / 1000}s — the report may have been recorded anyway` };
+        }
+        return { status: 'error', error: `network error: ${e instanceof Error ? e.message : String(e)}` };
     }
     let body = {};
     try {
@@ -211,6 +216,14 @@ export async function feedback(opts, deps = {}) {
         return;
     }
     const result = await submit(payload, deps.fetchImpl ?? fetch);
+    if (result.status === 'unconfirmed') {
+        // NOT a failure claim: the request was still in flight at the deadline and the server
+        // finishes what it started, so saying "not submitted" here would be a false negative.
+        if (opts.json)
+            return printJson({ status: 'unconfirmed', error: result.error });
+        process.stderr.write(`warning: feedback receipt unconfirmed (${result.error}) — continue with your task, do not retry\n`);
+        return;
+    }
     if (result.status === 'error') {
         // Deliberate exit 0: an agent CANNOT fix a down/rate-limited backend, and feedback must never
         // fail or distract from the task the user actually asked for. Do not retry.

package/dist/commands/setup.js

@@ -10,9 +10,10 @@ 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 { readPersistedGlobal, resolveEnv } from '../config.js';
+import { DEFAULT_ENV, ENVS, ENV_NAMES, envForApiUrl, envFromEnvVar, isEnvName, mcpServerName } from '../env.js';
 import { info } from '../util.js';
+import { envUse } from './env.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
@@ -316,10 +317,49 @@ 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, ensure = (r) => ensureCliInstalled(r)) {
+/** The environment `setup agent` should target, and whether the machine must be switched to it
+ *  first. Pure — decides only; the caller performs the switch.
+ *
+ *  The contract (CLI ≥ 0.0.38): the public one-liner `npx -y insta setup agent` means PRODUCTION,
+ *  full stop — a leftover `insta env use staging` from last month must not silently give a new
+ *  onboarding run staging skills. Staging is an explicit ask: `--env staging` (or $INSTA_ENV).
+ *  Two deliberate exceptions leave the machine alone:
+ *  - an explicit $INSTA_API_URL (insta-oss, a preview) with no --env — a hand-written URL is the
+ *    most specific instruction there is;
+ *  - a persisted CUSTOM apiUrl with no --env — same reasoning, chosen via login --api-url. */
+export function planSetupEnv(flagEnv, persistedApiUrl, apiUrlOverride = process.env.INSTA_API_URL, envVar = envFromEnvVar()) {
+    if (flagEnv !== undefined) {
+        const want = flagEnv.trim().toLowerCase();
+        if (!isEnvName(want))
+            throw new Error(`unknown --env "${flagEnv}" — expected one of: ${ENV_NAMES.join(', ')}`);
+        // A contradicting ambient override must ERROR, not lose quietly: everything after this plan
+        // resolves through resolveEnv(), where $INSTA_API_URL (and $INSTA_ENV) outrank the persisted
+        // config — proceeding would persist one environment and install another's skills/MCP.
+        if (apiUrlOverride)
+            throw new Error(`--env ${want} conflicts with $INSTA_API_URL=${apiUrlOverride} — unset one`);
+        if (envVar && envVar !== want)
+            throw new Error(`--env ${want} conflicts with $INSTA_ENV=${envVar} — unset one`);
+        return { target: want, switch: envForApiUrl(persistedApiUrl) !== want };
+    }
+    if (apiUrlOverride)
+        return { target: null, switch: false };
+    const persisted = envForApiUrl(persistedApiUrl);
+    if (persisted === null)
+        return { target: null, switch: false }; // custom host, chosen deliberately
+    const target = envVar ?? DEFAULT_ENV;
+    return { target, switch: persisted !== target };
+}
+export async function setupAgent(opts, run = defaultRunner, mint, installConfigs = installAgentConfigs, ensure = (r) => ensureCliInstalled(r), readStored = readPersistedGlobal, switchEnv = (n) => envUse(n)) {
     if (!opts.yes && !process.stdout.isTTY) {
         info('non-interactive shell — assuming -y');
     }
+    // Pin the environment BEFORE anything is installed (see planSetupEnv). A required switch goes
+    // through `env use` — the one path that persists the choice and drops the now-foreign session —
+    // and announces itself, so the machine can never end up with its CLI on one deployment and its
+    // skills/MCP on another.
+    const plan = planSetupEnv(opts.env, (await readStored()).apiUrl);
+    if (plan.switch && plan.target)
+        await switchEnv(plan.target);
     // 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);
@@ -351,5 +391,14 @@ export async function setupAgent(opts, run = defaultRunner, mint, installConfigs
     const others = await installConfigs();
     if (others.length)
         info(`✓ MCP — also configured for ${others.join(', ')} (restart those tools to pick it up)`);
+    // The checkmarks end the install, but the user's next move shouldn't be guesswork. Local state
+    // only (no network): a config with a session means logged in — good enough for a hint.
+    // Deliberately prod-hosted prompt.md even on a staging setup: it is generic onboarding (the
+    // login/create commands in it are env-aware at runtime), and staging serves no equivalent.
+    const stored = await readStored();
+    const loggedIn = !!(stored.accessToken || stored.user);
+    info(loggedIn
+        ? 'next: `insta project create <name>` in your app repo — or tell your agent: "Fetch https://instacloud.com/prompt.md and follow it"'
+        : 'next: `insta login --oauth github` (headless: `insta login --device`), then `insta project create <name>` — or tell your agent: "Fetch https://instacloud.com/prompt.md and follow it"');
 }
 //# sourceMappingURL=setup.js.map

package/dist/index.js

@@ -82,8 +82,9 @@ program.command('run <cmd> [args...]').description('Run a command with the branc
     .action(guard((cmd, args, o) => runCmd.run([cmd, ...(args ?? [])], o)));
 // ---- agent setup (the `curl … | sh --agents` target) ----
 const setupCmd = program.command('setup').description('Set up this machine for InstaCloud agent workflows');
-setupCmd.command('agent').description('Install the insta CLI (if missing), the insta skill for all coding agents, and the MCP server')
+setupCmd.command('agent').description('Install the insta CLI (if missing), the insta skill for all coding agents, and the MCP server — targets production; pass --env staging for the staging deployment')
     .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)')
     .action(guard((o) => setup.setupAgent(o)));
 // ---- MCP server integration ----

package/package.json

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