insta 0.0.65 → 0.0.66

package/dist/agent.js

@@ -61,7 +61,13 @@ export async function loadAgentSession(apiUrl, projectId, cwd = process.cwd()) {
         throw new Error(guidance);
     }
 }
-export async function agentHeaders(api, method, path, rawBody) {
+// Routes the CLI may call on an account-level (bootstrap) session, by first path segment. Every
+// other route is project-owned: either its path names the project or the caller passes
+// scope.projectId. A miss fails HERE, naming the route, instead of on the platform as a
+// "for a different project" 403 whose setup hint cannot help — keep this list in step with the
+// account-level paths in src/commands/.
+export const ACCOUNT_ROUTES = new Set(['agent', 'auth', 'me', 'orgs', 'regions', 'templates', 'tokens', 'github']);
+export async function agentHeaders(api, method, path, rawBody, scope = {}) {
     if (!mode)
         return {};
     if (canonicalTarget(path) === '/agent/sessions' && method === 'POST')
@@ -70,9 +76,13 @@ export async function agentHeaders(api, method, path, rawBody) {
         };
     const target = canonicalTarget(path);
     const match = target.match(/^\/projects\/([^/?]+)/);
+    const projectId = scope.projectId ?? (match ? decodeURIComponent(match[1]) : undefined);
+    if (!projectId && !ACCOUNT_ROUTES.has(target.split('/')[1]?.split('?')[0] ?? '')) {
+        throw new Error(`${method.toUpperCase()} ${target} is a project route but no project was given — this is an insta CLI bug; please report it with \`insta feedback\``);
+    }
     // Account reads/project creation have no project policy yet. Mint a short-lived bootstrap
     // assertion in memory. It cannot access project routes; never downgrade to a human request.
-    const session = match ? await loadAgentSession(api.apiUrl, decodeURIComponent(match[1])) : await issueAgentSession(api);
+    const session = projectId ? await loadAgentSession(api.apiUrl, projectId) : await issueAgentSession(api);
     const timestamp = String(Math.floor(Date.now() / 1000));
     const nonce = randomUUID();
     const proof = [method.toUpperCase(), target, hash(rawBody), session.agentSessionId, timestamp, nonce, mode.source, session.client].join('\n');

package/dist/api.js

@@ -60,7 +60,7 @@ export class ApiClient {
     }
     // Returns parsed body for status < 400 (incl. 202); throws ApiError otherwise.
     async request(method, path, body, opts = {}) {
-        const res = await this.raw(method, path, body, opts.auth ?? true);
+        const res = await this.raw(method, path, body, opts.auth ?? true, opts);
         if (agentMode() && res.status === 202 && res.body?.status === 'approval_required')
             throw new AgentApprovalRequired(res.body);
         if (res.status >= 400)
@@ -69,25 +69,25 @@ export class ApiClient {
     }
     // Like request but returns {status, body} so callers can branch on 202 (approval_required).
     async rawRequest(method, path, body, opts = {}) {
-        const res = await this.raw(method, path, body, opts.auth ?? true);
+        const res = await this.raw(method, path, body, opts.auth ?? true, opts);
         if (res.status >= 400)
             throw new ApiError(res.status, res.body?.error ?? `HTTP ${res.status}`, res.body);
         return res;
     }
-    async raw(method, path, body, auth) {
-        let r = await this.fetch(method, path, body, auth);
+    async raw(method, path, body, auth, scope = {}) {
+        let r = await this.fetch(method, path, body, auth, scope);
         if (r.status === 401 && auth && this.cfg.refreshToken) {
             if (await this.refresh())
-                r = await this.fetch(method, path, body, auth);
+                r = await this.fetch(method, path, body, auth, scope);
         }
         return r;
     }
-    async fetch(method, path, body, auth) {
+    async fetch(method, path, body, auth, scope = {}) {
         const headers = { 'Content-Type': 'application/json', 'Insta-Hints': '1', 'User-Agent': USER_AGENT };
         if (auth && this.cfg.accessToken)
             headers.Authorization = `Bearer ${this.cfg.accessToken}`;
         if (auth)
-            Object.assign(headers, await agentHeaders(this, method, path, body === undefined ? '' : JSON.stringify(body)));
+            Object.assign(headers, await agentHeaders(this, method, path, body === undefined ? '' : JSON.stringify(body), scope));
         const res = await this.fetchImpl(this.apiUrl + path, {
             method,
             headers,

package/dist/commands/auth.js

@@ -116,7 +116,8 @@ export async function applyApiKeyLogin(client, key) {
 const sleepSeconds = (s) => new Promise((r) => setTimeout(r, s * 1000));
 // Drives the device grant against the platform's Better Auth mount (/api/auth/device*) and
 // returns the approved session token. Injectable poster + wait keep this testable without a
-// network or real timers. Poll errors arrive as ApiError with the OAuth error code as message.
+// network or real timers. Poll errors arrive as ApiError with the OAuth error code as message
+// (or a bare `HTTP 429` from the platform's rate limiter, treated as slow_down).
 // `open` (the default browser-login path) launches the verification link locally on top of
 // printing it; without it (--device) the link is print-only, for a browser on another machine.
 export async function deviceGrant(post, wait = sleepSeconds, open) {
@@ -169,6 +170,14 @@ export async function deviceGrant(post, wait = sleepSeconds, open) {
                 interval += 5;
                 continue;
             } // RFC 8628 §3.5: back off by 5s
+            // The platform's per-IP limiter answers a bare HTTP 429 (no OAuth error code) when a poll
+            // trips it — seen on prod 2026-09-10 after ~8 min of steady 5s polling. That is the same
+            // instruction as slow_down: the code is still pending, so back off and keep waiting rather
+            // than abort a login the human may be one click away from approving.
+            if (e.status === 429) {
+                interval += 5;
+                continue;
+            }
             if (code === 'expired_token')
                 break;
             if (code === 'access_denied')

package/dist/commands/github.js

@@ -32,6 +32,14 @@ export function pickCandidate(candidates, rootDir) {
         ...candidates.map((c) => `  ${(c.rootDir ?? '(repo root)').padEnd(24)} ${c.builder}${c.startCommand ? `  start: ${c.startCommand}` : ''}`),
     ].join('\n'));
 }
+// A comma-separated list, because a shell would glob an unquoted `apps/web/**` into filenames — which
+// also means a pattern containing a comma cannot be expressed. The server does the validation.
+export function parseWatchPaths(raw) {
+    const out = raw.split(',').map((p) => p.trim()).filter(Boolean);
+    if (!out.length)
+        throw new Error("watch paths need at least one pattern, e.g. 'apps/web/**,packages/ui/**' (quote them, or the shell expands the *)");
+    return out;
+}
 // Build/start come from detection only: the platform's nixpacks lane fails a build whose commands differ from it.
 // autoDeploy rides along only when switched off: a public repo 400s on autoDeploy: true.
 export function sourceBody(src, c, o) {
@@ -46,8 +54,14 @@ export function sourceBody(src, c, o) {
         port: o.port !== undefined ? parsePort(o.port) : c.port,
         ...(o.repoBranch ? { branch: o.repoBranch } : {}),
         ...(o.autoDeploy === false ? { autoDeploy: false } : {}),
+        ...(o.watchPaths !== undefined ? { watchPaths: parseWatchPaths(o.watchPaths) } : {}),
     };
 }
+// Named as repo-root paths wherever it is printed: every line that carries this also carries root_dir,
+// which the patterns are NOT relative to.
+export function watchPathsClause(paths) {
+    return `, but only when a push changes these repo-root paths: ${paths.join(', ')}`;
+}
 export function repoLine(serviceName, s) {
     if (s.type !== 'github')
         return `compute ${serviceName}: no repository connected${s.image ? ` (runs image ${s.image})` : ''} — connect one with \`insta compute connect-repo <owner/repo> ${serviceName}\``;
@@ -55,7 +69,10 @@ export function repoLine(serviceName, s) {
         ? 'public repo, deploys are manual (pushes do not redeploy)'
         : s.auto_deploy ? `every push to ${s.branch} redeploys it` : 'auto-deploy off (pushes do not redeploy)';
     const where = s.root_dir ? ` (${s.root_dir}/)` : '';
-    return `compute ${serviceName}: deploys from ${s.owner}/${s.repo}@${s.branch}${where} — ${how}`;
+    const only = !s.watch_paths?.length ? ''
+        : s.auto_deploy ? watchPathsClause(s.watch_paths)
+            : `; watch paths ${s.watch_paths.join(', ')} are stored but cannot apply`;
+    return `compute ${serviceName}: deploys from ${s.owner}/${s.repo}@${s.branch}${where} — ${how}${only}`;
 }
 export async function findInstalledRepo(api, orgId, ref) {
     if (!orgId)
@@ -105,11 +122,31 @@ export async function computeConnectRepo(rawRef, serviceName, opts) {
     const branch = res.source.branch;
     const where = candidate.rootDir ? `${candidate.rootDir}/, ${candidate.builder}` : candidate.builder;
     const now = res.build.queued ? `building ${branch} now` : `${branch} is already live at this commit`;
+    // From the server's answer, not from the flag: what it stored is what a push is matched against.
+    const filtered = res.source.watch_paths?.length ? watchPathsClause(res.source.watch_paths) : '';
     const how = src.source === 'public' ? 'deploys are manual from here: pushes will not redeploy (public repo)'
         : opts.autoDeploy === false ? 'auto-deploy is off: redeploy with `insta compute connect-repo` again or from the console'
-            : `every push to ${branch} redeploys it`;
+            : `every push to ${branch} redeploys it${filtered}`;
     info(`connected ${ref.owner}/${ref.repo} → compute ${svc.name} (${where}): ${now} — ${how}`);
 }
+// Do not reconnect to change these: watch paths do not change what a build produces, and `connect-repo`
+// would rebuild the service.
+export async function computeWatchPaths(serviceName, opts) {
+    if (opts.set !== undefined && opts.clear)
+        throw new Error('pass --set or --clear, not both');
+    const patch = opts.clear ? { watchPaths: null } : opts.set !== undefined ? { watchPaths: parseWatchPaths(opts.set) } : null;
+    const api = await ApiClient.load();
+    const p = await requireProject();
+    const branch = opts.branch ?? p.branch;
+    const svc = await targetService(api, p.projectId, branch, serviceName);
+    const url = `/projects/${p.projectId}/services/${svc.id}/source${q(branch)}`;
+    const { source } = patch
+        ? await api.request('PATCH', url, patch)
+        : await api.request('GET', url);
+    if (opts.json)
+        return printJson({ service: { id: svc.id, name: svc.name }, source });
+    info(patch ? `updated — ${repoLine(svc.name, source)}` : repoLine(svc.name, source));
+}
 export async function computeDisconnectRepo(serviceName, opts) {
     const api = await ApiClient.load();
     const p = await requireProject();

package/dist/commands/template.js

@@ -374,7 +374,9 @@ export async function templateDeploy(target, opts = {}, deps = {}) {
     const codeLabel = manifest?.code ?? target;
     if (!quiet)
         info(`deploying template ${codeLabel} to branch ${branchName} (${deploymentId})`);
-    const dep = await watchDeployment((id) => api.request('GET', `/template-deployments/${id}`), deploymentId, quiet ? () => { } : info, deps.wait);
+    // The poll route is keyed by deployment id, not project: name the project so agent mode signs
+    // with the project-bound session (a bootstrap session is rejected as "for a different project").
+    const dep = await watchDeployment((id) => api.request('GET', `/template-deployments/${id}`, undefined, { projectId: p.projectId }), deploymentId, quiet ? () => { } : info, deps.wait);
     if (opts.json)
         return printJson(source ? { source, ...dep } : dep);
     info(`template ${codeLabel} deployed to branch ${branchName}`);

package/dist/index.js

@@ -252,16 +252,21 @@ const execCmd = compute.command('exec [service]').description("Run a one-shot co
 // 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('repo [service]').description('Show what a compute service deploys from: the image it runs, or the GitHub repository — owner/repo, the branch it builds, root directory, and whether pushes redeploy it')
+compute.command('repo [service]').description('Show what a compute service deploys from: the image it runs, or the GitHub repository — owner/repo, the branch it builds, root directory, which paths a push must change to redeploy it, and whether pushes redeploy it at all')
     .option('--json').option('--branch <branch>', 'branch (default: current)').action(guard((service, o) => githubCmd.computeRepo(service, o)));
 compute.command('connect-repo <owner/repo> [service]').description("Connect a GitHub repository to an EXISTING compute service: the repo is built (its Dockerfile, or nixpacks when there is none) and deployed into that service, and every later push to the tracked repository branch redeploys it. The repo must be reachable through the org's GitHub App installation — connect GitHub in the console first (Add Service → GitHub Repo) — or be public. Build and start commands come from detection and cannot be set. Connecting again replaces the service's current source")
     .option('--public', 'the repo is public and no GitHub App installation is needed (deploys are manual; pushes cannot redeploy)')
     .option('--root-dir <dir>', 'the directory of the repo to build (a monorepo with several deployable directories lists them and exits 1 without it)')
     .option('--repo-branch <name>', "the repository branch to build (default: the repo's default branch)")
     .option('--no-auto-deploy', 'do not rebuild on pushes; redeploy by connecting again or from the console')
+    .option('--watch-paths <patterns>', "only redeploy when a push changes a matching path — a comma-separated list of gitignore patterns relative to the REPOSITORY ROOT, not to --root-dir, e.g. 'apps/web/**,packages/ui/**' (quote them, or the shell expands the *)")
     .option('--port <n>', 'port the app listens on (default: detected)')
     .option('--branch <branch>', 'branch (default: current) — the environment the service is on')
     .option('--json').action(guard((ref, service, o) => githubCmd.computeConnectRepo(ref, service, o)));
+compute.command('watch-paths [service]').description("Show or change which paths make a push redeploy a compute service. No flag prints them. --set narrows to a comma-separated list of gitignore patterns matched against paths relative to the REPOSITORY ROOT (not to the service's root directory), so a monorepo push that touched nothing on the list leaves this service alone — unless GitHub cannot report what a push changed (a force-push, or a comparison of 300 or more files, where its list stops being complete), in which case it deploys rather than risk skipping a real change. --clear removes the filter: every push that deploys this service deploys it again. Neither rebuilds the service — this changes which pushes deploy, not what a deploy builds")
+    .option('--set <patterns>', "the patterns, comma-separated, e.g. 'apps/web/**,packages/ui/**' — quote them, or the shell expands the *; a leading ! excludes, under git's rule that a path cannot be re-included once an earlier pattern took its directory")
+    .option('--clear', 'remove the filter: every push that deploys this service deploys it again')
+    .option('--json').option('--branch <branch>', 'branch (default: current)').action(guard((service, o) => githubCmd.computeWatchPaths(service, o)));
 compute.command('disconnect-repo [service]').description('Disconnect the GitHub repository from a compute service. The service keeps running its current image; pushes no longer deploy it, and its build history stays')
     .option('--json').option('--branch <branch>', 'branch (default: current)').action(guard((service, o) => githubCmd.computeDisconnectRepo(service, o)));
 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 10Gi, the free cap; 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")

package/package.json

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