insta 0.0.68 → 0.0.69

package/README.md

@@ -16,7 +16,7 @@ Native binary, no Node required (macOS / Linux / WSL). Installs to `~/.insta/bin
 verifies the download against `SHA256SUMS`:
 
 ```bash
-curl -fsSL https://raw.githubusercontent.com/InsForge/insta-cli/main/install.sh | sh
+curl -fsSL https://raw.githubusercontent.com/InsForge/instacloud-cli/main/install.sh | sh
 ```
 
 From npm:
@@ -48,7 +48,7 @@ On macOS/Linux without Node, the native-binary installer puts the `insta` CLI on
 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):
+[releases page](https://github.com/InsForge/instacloud-cli/releases):
 
 ```bash
 curl -fsSL agents.instacloud.com | sh
@@ -74,7 +74,9 @@ insta deploy .
 opt-in, so you add only what you need. `secrets` writes the current branch's user-defined
 secrets to `./.env` (the postgres connection string is read with `insta db url`). `deploy .`
 builds the directory remotely and ships it to the branch's compute
-service; it needs a `Dockerfile`, but no local Docker.
+service, with no local Docker. Whether it needs a `Dockerfile` depends on where the
+service runs: on insta-compute it is optional, and a directory without one is built
+by nixpacks on the build gateway; on Fly-backed services one is still required.
 
 ## Authentication
 
@@ -157,7 +159,7 @@ other, so switching environments drops the stored session and you log in again.
 | control plane | `api.instacloud.com` | `api.staging.instacloud.com` |
 | MCP server | `mcp.instacloud.com/mcp` | `mcp.staging.instacloud.com/mcp` |
 | MCP registers as | `insta-cloud` | `insta-cloud-staging` |
-| agent skills | `InsForge/insta-skills` | `InsForge/insta-skills#devel` |
+| agent skills | `InsForge/instacloud-skills` | `InsForge/instacloud-skills#devel` |
 | CLI channel | latest stable release | newest prerelease, else stable |
 
 ```bash
@@ -180,7 +182,7 @@ That host is a CloudFront cache, so after a change to the installer it can serve
 previous copy for up to about a day. This form is equivalent and always current:
 
 ```bash
-curl -fsSL https://raw.githubusercontent.com/InsForge/insta-cli/main/install.sh | sh -s -- --agents --staging
+curl -fsSL https://raw.githubusercontent.com/InsForge/instacloud-cli/main/install.sh | sh -s -- --agents --staging
 ```
 
 If the environment cannot be applied — an installed CLI older than 0.0.23 has no `insta
@@ -204,7 +206,7 @@ build never reaches a production installer.
 ## Commands
 
 `insta --help` is the authoritative list. For flags, approval gates and plan limits, see the
-[full command reference](https://github.com/InsForge/insta-skills/blob/main/insta/cli-reference.md).
+[full command reference](https://github.com/InsForge/instacloud-skills/blob/main/insta/cli-reference.md).
 
 | Command | What it covers |
 |---|---|
@@ -252,7 +254,7 @@ build never reaches a production installer.
 ## Agent skills
 
 The `insta` skill and its task guides live in
-[InsForge/insta-skills](https://github.com/InsForge/insta-skills). `insta setup agent`
+[InsForge/instacloud-skills](https://github.com/InsForge/instacloud-skills). `insta setup agent`
 installs it user-globally for every coding agent on the machine. `insta project create` and
 `insta project link` additionally install the stack skills (Tigris, Better Auth) into the
 project, along with the `insta observe` credential-audit hook. Postgres needs no stack

package/dist/api.js

@@ -77,7 +77,7 @@ export class ApiClient {
     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())
+            if (await this.refresh(scope.signal))
                 r = await this.fetch(method, path, body, auth, scope);
         }
         return r;
@@ -92,6 +92,7 @@ export class ApiClient {
             method,
             headers,
             body: body === undefined ? undefined : JSON.stringify(body),
+            signal: scope.signal,
         });
         const text = await res.text();
         let parsed = null;
@@ -103,9 +104,9 @@ export class ApiClient {
         }
         return { status: res.status, body: parsed };
     }
-    async refresh() {
+    async refresh(signal) {
         try {
-            const res = await this.fetch('POST', '/auth/refresh', { refreshToken: this.cfg.refreshToken }, false);
+            const res = await this.fetch('POST', '/auth/refresh', { refreshToken: this.cfg.refreshToken }, false, { signal });
             if (res.status >= 400)
                 return false;
             this.cfg.accessToken = res.body.accessToken;
@@ -113,7 +114,12 @@ export class ApiClient {
             await this.persist();
             return true;
         }
-        catch {
+        catch (e) {
+            // Refresh belongs to the original request's time budget. Do not turn its cancellation
+            // into the earlier 401: the caller needs the abort to report a timeout or cancellation.
+            signal?.throwIfAborted();
+            if (e instanceof Error && (e.name === 'AbortError' || e.name === 'TimeoutError'))
+                throw e;
             return false;
         }
     }

package/dist/commands/build.js

@@ -155,21 +155,21 @@ export async function buildReport(dirArg, opts, deps) {
     const envKeys = existsSync(envExample) ? envKeysFromDotEnvExample(readFileSync(envExample, 'utf8')) : [];
     const checks = [];
     // Only a Dockerfile IN the directory passes. A nixpacks-generated one is a real plan, but it is
-    // not a plan `insta deploy <dir>` can execute: that path builds the directory's own Dockerfile and
-    // dies without one, and the nixpacks lane runs server-side for GitHub-connected repos only. This
-    // check used to pass on the generated Dockerfile, so a verifier said "deployable" about a
-    // directory `deploy` refuses — the whole point of the command is to not do that.
+    // not one this machine can hand to every target: on a Fly-backed service `insta deploy <dir>`
+    // builds the directory's own Dockerfile and dies without one. On insta-compute the gateway runs
+    // nixpacks itself, so the same directory ships. The check stays a non-pass because it cannot know
+    // the target, and the detail below says both halves rather than promising either.
     checks.push(dockerfile.source === 'nixpacks'
         ? {
             id: 'dockerfile',
             severity: 'warning',
             status: 'fail',
             title: 'Dockerfile',
-            detail: `${dockerfileDetail} — but \`insta deploy <dir>\` builds the directory's own Dockerfile; the nixpacks lane runs server-side for GitHub-connected repos only`,
+            detail: `${dockerfileDetail} — \`insta deploy <dir>\` builds this on the gateway with nixpacks when the service runs on insta-compute, and needs your own Dockerfile on a Fly-backed one`,
             // NOT "save the generated Dockerfile here": it is not standalone (it COPYs the
             // .nixpacks/nixpkgs-<hash>.nix support files nixpacks writes beside it, which this
             // directory does not have). The detected commands above are the reusable part.
-            nextAction: `to deploy this directory, write a Dockerfile at ${userDockerfilePath} — the detected install/start commands above are the starting point; or connect the GitHub repo to the service (\`insta compute connect-repo <owner/repo>\`) to use the nixpacks lane`,
+            nextAction: `on insta-compute this deploys as-is (nixpacks builds it on the gateway). On a Fly-backed service, write a Dockerfile at ${userDockerfilePath} — the detected install/start commands above are the starting point — or connect the GitHub repo (\`insta compute connect-repo <owner/repo>\`)`,
         }
         : {
             id: 'dockerfile',
@@ -225,8 +225,9 @@ export function renderReport(r, explain) {
     const lines = [];
     lines.push(`plan for ${r.dir}:`);
     // The builder line is the first thing read (and the thing an agent scrapes), so it carries the
-    // lane caveat too — "builder: nixpacks" on its own reads as a promise `insta deploy <dir>` breaks.
-    const lane = r.plan.builder === 'nixpacks' ? ' — GitHub lane only (`insta compute connect-repo`); `insta deploy <dir>` needs a Dockerfile' : '';
+    // lane caveat too — "builder: nixpacks" on its own reads as a promise that is only true on some
+    // targets. It has to say the SAME thing the detail below it says, or a scrape sees both claims.
+    const lane = r.plan.builder === 'nixpacks' ? ' — server-side: insta-compute builds this as-is, a Fly-backed service needs your own Dockerfile' : '';
     lines.push(`  builder: ${r.plan.builder ?? 'none'}${r.plan.providers.length ? ` (providers: ${r.plan.providers.join(', ')})` : ''}${lane}`);
     if (r.plan.installCommand)
         lines.push(`  install: ${r.plan.installCommand}`);

package/dist/commands/deploy.js

@@ -3,14 +3,17 @@ import { existsSync, readFileSync } from 'node:fs';
 import { ApiClient, ApiError, requireProject } from '../api.js';
 import { info, die, printJson, handleApproval, renderNextActions, CliExit } from '../util.js';
 import { flyctlBuildAndPush, ensureFlyctl, defaultBuildRunner, stderrBuildRunner } from '../flyctl-build.js';
+import { packDirectory, windowsModeCaveat } from '../pack.js';
+import { deployArchive, uploadArchive } from '../deploy-archive.js';
+import { parsePort } from './services.js';
 // With --json, stdout must carry exactly one JSON document (the deploy result), so every progress
 // line moves to stderr.
 const note = (opts) => (opts.json ? (m) => void process.stderr.write(m + '\n') : info);
 // Map CLI options to the platform deploy request body. Pure, so it's unit-tested. --websocket is only
-// sent when set (plain deploys unchanged).
-export function deployRequestBody(image, branch, opts) {
+// sent when set (plain deploys unchanged). Exactly one of image | archive rides along.
+export function deployRequestBody(source, branch, opts) {
     return {
-        image,
+        image: source.image,
         branch,
         group: opts.group,
         port: opts.port ? Number(opts.port) : undefined,
@@ -18,6 +21,82 @@ export function deployRequestBody(image, branch, opts) {
         replaceSource: opts.replaceSource ? true : undefined,
     };
 }
+// Ask the platform which lane serves this target, so the CLI stops knowing which provider backs
+// its service. A 404 means the platform predates the contract — and because this is a GET, it
+// 404s the same way for a human and an agent, which a POST would not.
+async function discoverLane(api, projectId, branch, opts) {
+    const q = new URLSearchParams({ branch, ...(opts.group ? { group: opts.group } : {}) });
+    try {
+        const res = await api.rawRequest('GET', `/projects/${projectId}/source-build?${q}`);
+        // Validated, not cast. Every value other than the four we know silently fell through to the
+        // flyctl path below, so a server that grew a fifth lane would send this CLI down the wrong
+        // one and fail somewhere unrelated. An unknown answer is the server being ahead of us, and
+        // saying that is more useful than guessing.
+        const lane = (res.body ?? {});
+        const tag = lane.lane ?? '';
+        const known = ['flyctl', 'local-docker', 'archive', 'none'];
+        if (!known.includes(tag)) {
+            die(`this platform answered with a source-build lane this CLI does not know (${JSON.stringify(tag)}) — upgrade with \`insta upgrade\``);
+        }
+        // The tag alone is not the contract: each branch carries a payload this code then trusts.
+        // An `archive` with malformed limits fell back to local defaults, so the CLI would enforce
+        // caps the SERVER does not have, and a `none` with no reason died with `undefined`.
+        if (tag === 'archive') {
+            const l = lane.limits;
+            const positive = (v) => typeof v === 'number' && Number.isSafeInteger(v) && v > 0;
+            if (!l || !positive(l.maxArchiveBytes) || !positive(l.maxExtractedBytes) || !positive(l.maxFiles)) {
+                die('this platform offered the archive lane without usable size limits — upgrade with `insta upgrade`');
+            }
+        }
+        const reason = lane.reason;
+        if (tag === 'none' && (typeof reason !== 'string' || !reason.trim())) {
+            die('this platform refused a source build without saying why — upgrade with `insta upgrade`');
+        }
+        return lane;
+    }
+    catch (e) {
+        if (e instanceof ApiError && e.status === 404) {
+            // The route answered and the TARGET is what is missing: say so, or flyctl turns it into "no Dockerfile".
+            // Both ways out: the project has several groups and none is named, or it has none at all.
+            if (/compute group not found|branch not found/.test(e.message))
+                die(`${e.message} — name it with \`--group <name>\` (see \`insta services list\`), or add one: \`insta services add compute <name>\``);
+            return { lane: 'legacy' };
+        }
+        throw e;
+    }
+}
+// Turn a source directory into something deployable. Returns null when an approval is pending.
+export async function prepareSource(api, projectId, dir, branch, opts, run = opts.json ? stderrBuildRunner : defaultBuildRunner, upload) {
+    const lane = await discoverLane(api, projectId, branch, opts);
+    if (lane.lane === 'none')
+        die(lane.reason);
+    if (lane.lane !== 'archive') {
+        // flyctl, local-docker and legacy all end in an image, and all three need a Dockerfile.
+        return { image: await buildFromSource(api, projectId, dir, branch, opts, run) };
+    }
+    const log = note(opts);
+    const absDir = resolve(process.cwd(), dir);
+    const caveat = windowsModeCaveat();
+    if (caveat)
+        log(caveat);
+    const packed = packDirectory(absDir, lane.limits);
+    log(`packed ${dir}: ${packed.files} files, ${packed.archive.length} bytes`);
+    const ref = await uploadArchive(api, projectId, packed, branch, opts, upload);
+    if (!ref)
+        return null;
+    log(`deploying ${packed.archive.length} bytes via the gateway (${ref.build.type})`);
+    // One gated call enqueues build+deploy as an operation; the wait is ours, one short poll at a
+    // time, because a platform request has to answer inside the ALB's 60s while a build runs minutes.
+    // A repo-connected service refuses this with a 409 the same way it refuses an image deploy, and
+    // the hint that names the FLAG rather than the API field lives here, beside the `/deploy` path.
+    const out = await deployArchive(api, projectId, ref, branch, opts, Date.now, undefined, log)
+        .catch((e) => { throw e instanceof ApiError && e.status === 409 ? new ApiError(e.status, repoConnectedHint(e.message), e.body) : e; });
+    if (!out)
+        return null;
+    if ('failed' in out)
+        die(out.failed);
+    return { deployed: out };
+}
 // A port mismatch is the #1 deploy mistake: the app boots "successfully" but the proxy routes to
 // the wrong internal port and every request is refused. For source deploys the Dockerfile states
 // the truth — use its (last) EXPOSE as the default instead of a blind 8080.
@@ -30,10 +109,10 @@ export function dockerfileExposedPort(dockerfile) {
     }
     return port;
 }
-// A directory deploy builds the Dockerfile IN the directory — there is no no-Dockerfile lane here.
-// The nixpacks (no-Dockerfile) lane is real but server-side: it runs on the build gateway for
-// GitHub-connected repos only, and nothing reachable from `insta deploy <dir>` can enter it. So the
-// dead-end message names every way forward instead of the bare "add one".
+// This message is for the target that still REQUIRES a Dockerfile: a Fly-backed service, where a
+// directory deploy builds the Dockerfile in the directory and dies without one. On insta-compute
+// the archive lane carries the directory to the gateway and nixpacks builds it, so this dead end is
+// no longer universal. It names every way forward instead of the bare "add one".
 //
 // It deliberately does NOT say "save the Dockerfile `insta build --explain` prints": that file is
 // not standalone — it COPYs `.nixpacks/nixpkgs-<hash>.nix` support files nixpacks writes beside it,
@@ -60,7 +139,16 @@ export async function deploy(dir, opts) {
     const p = await requireProject();
     const branch = opts.branch ?? p.branch;
     const log = note(opts);
-    let port = opts.port ? Number(opts.port) : undefined;
+    // Junk fails here, before a directory is packed and uploaded for a body the platform would only
+    // refuse: the same parser every other --port in this CLI runs. `Number()` alone sent NaN as
+    // `null` and let 0 or 70000 travel to the server.
+    let port;
+    try {
+        port = opts.port === undefined ? undefined : parsePort(opts.port);
+    }
+    catch (e) {
+        die(`--${e.message}`);
+    }
     if (dir && port === undefined) {
         const dockerfile = join(resolve(process.cwd(), dir), 'Dockerfile');
         const exposed = existsSync(dockerfile) ? dockerfileExposedPort(readFileSync(dockerfile, 'utf8')) : undefined;
@@ -70,14 +158,26 @@ export async function deploy(dir, opts) {
         }
     }
     const effOpts = { ...opts, port: port?.toString() };
-    const image = dir ? await buildFromSource(api, p.projectId, dir, branch, effOpts) : opts.image;
-    const res = await api.rawRequest('POST', `/projects/${p.projectId}/deploy`, deployRequestBody(image, branch, effOpts))
+    const source = dir ? await prepareSource(api, p.projectId, dir, branch, effOpts) : { image: opts.image };
+    if (!source)
+        return; // an approval is pending; the user approves and re-runs
+    if ('deployed' in source) {
+        // The archive lane's operation already deployed. One output shape whichever lane ran, minus
+        // nextActions, which the operation read does not carry.
+        const d = source.deployed;
+        if (opts.json)
+            return printJson({ image: d.image, url: d.url, branch: d.branch, group: d.group, machineId: d.machineId });
+        info(`deployed ${d.image} -> ${d.url} (branch ${d.branch}, group ${d.group})`);
+        return;
+    }
+    const res = await api.rawRequest('POST', `/projects/${p.projectId}/deploy`, deployRequestBody(source, branch, effOpts))
         .catch((e) => { throw e instanceof ApiError && e.status === 409 ? new ApiError(e.status, repoConnectedHint(e.message), e.body) : e; });
     if (handleApproval(res, opts.json))
         return;
+    const what = source.image;
     if (opts.json)
-        return printJson({ image, ...res.body });
-    info(`deployed ${image} -> ${res.body.url} (branch ${res.body.branch}, group ${res.body.group})`);
+        return printJson({ image: source.image, ...res.body });
+    info(`deployed ${what} -> ${res.body.url} (branch ${res.body.branch}, group ${res.body.group})`);
     renderNextActions(res.body.nextActions);
 }
 // The platform refuses an image deploy onto a repo-connected service and names the body field it

package/dist/commands/feedback.js

@@ -4,7 +4,7 @@
 // server, the platform, the skills, the docs. Never for problems in the app the user is building.
 //
 // The backend is InstaCloud dogfooding itself: the "InstaCloud Agent Feedback" project runs the
-// ingest service (InsForge/insta-feedback repo) on a postgres + compute pair. It is NOT the
+// ingest service (InsForge/instacloud-feedback repo) on a postgres + compute pair. It is NOT the
 // control-plane API on purpose — feedback must work logged-out, unlinked, and from insta-oss,
 // and a control-plane outage is exactly when we most want reports to still arrive.
 import { readFileSync, statSync } from 'node:fs';

package/dist/commands/upgrade.js

@@ -24,7 +24,7 @@ import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { readGlobal, writeGlobal } from '../config.js';
 import { resolveSpawnable } from '../spawn.js';
 import { info } from '../util.js';
-const INSTALL_SH = 'https://raw.githubusercontent.com/InsForge/insta-cli/main/install.sh';
+const INSTALL_SH = 'https://raw.githubusercontent.com/InsForge/instacloud-cli/main/install.sh';
 // The dist-tag document is the authoritative, tiny (~50 byte) answer for `latest`. The full
 // `latest` manifest is the fallback if that route is ever unavailable.
 const REGISTRY_DIST_TAGS = 'https://registry.npmjs.org/-/package/insta/dist-tags';

package/dist/deploy-archive.js

@@ -0,0 +1,145 @@
+import { handleApproval } from './util.js';
+export function archiveBuildSpec(hasDockerfile) {
+    return hasDockerfile ? { type: 'dockerfile' } : { type: 'nixpacks' };
+}
+const defaultUpload = async (url, body) => {
+    const res = await fetch(url, { method: 'PUT', body });
+    if (!res.ok)
+        throw new Error(`uploading the archive failed: HTTP ${res.status}`);
+};
+const statusPath = (projectId, sha256) => `/projects/${projectId}/build-uploads/${sha256}`;
+// Put an archive where the build gateway can fetch it, and answer what the deploy body needs.
+// Returns null when an approval is pending — the caller stops, the user approves and re-runs.
+//
+// The status read comes FIRST and that ordering is the whole recovery story: it is ungated, the
+// packer is deterministic and the upload id is derived from the content, so a re-run after an
+// approval finds the object already there, skips the gated mint it no longer needs, and submits a
+// byte-identical deploy body. That is why no resumable state is written to disk.
+export async function uploadArchive(api, projectId, packed, branch, opts, upload = defaultUpload) {
+    const ref = { archiveSha256: packed.sha256, build: archiveBuildSpec(packed.hasDockerfile) };
+    // The id the platform derives storage from is this digest, so an object that is already there is
+    // BYTE-IDENTICAL to the one in hand and the ref describes it truthfully. Keying on the tar digest
+    // instead bought cross-runtime dedup and paid for it with a lie: a Bun re-run of a Node upload
+    // matched the id, skipped the upload, and sent Bun's digest for Node's bytes, which the worker
+    // then rejected on every attempt until the object expired.
+    const first = await api.rawRequest('GET', statusPath(projectId, packed.sha256));
+    if (first.body?.state === 'valid')
+        return ref;
+    const minted = await api.rawRequest('POST', `/projects/${projectId}/build-uploads`, {
+        branch,
+        group: opts.group,
+        sha256: packed.sha256,
+        size: packed.archive.length,
+    });
+    if (handleApproval(minted, opts.json))
+        return null;
+    // The mint's whole product is this URL. An absent one would be PUT to as the string
+    // "undefined" and the failure would surface two steps later as a missing object.
+    const uploadUrl = minted.body?.uploadUrl;
+    if (typeof uploadUrl !== 'string' || !uploadUrl)
+        throw new Error('the platform minted an upload with no URL — re-run the deploy');
+    await upload(uploadUrl, packed.archive);
+    // Never let the deploy call be the thing that discovers a failed upload: its grant is spent in
+    // the governance preHandler, so a retry would need a NEW approval.
+    const after = await api.rawRequest('GET', statusPath(projectId, packed.sha256));
+    if (after.body?.state !== 'valid') {
+        throw new Error('the archive upload did not land — re-run the deploy to try again');
+    }
+    return ref;
+}
+// How often to ask, and how long to keep asking. The platform submits the build and returns; the
+// WAIT is ours, one short request at a time, because a deploy is answered synchronously and the
+// ALB in front of the platform cuts an idle request at 60s while an image build runs minutes.
+const POLL_MS = 3000;
+const DEPLOY_DEADLINE_MS = 30 * 60 * 1000;
+// One status read is a small GET; anything longer than this is a stalled endpoint, not a slow one.
+const POLL_REQUEST_TIMEOUT_MS = 20_000;
+const isAbort = (e) => e instanceof Error && (e.name === 'TimeoutError' || e.name === 'AbortError');
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+// ONE gated call, then a poll. The platform enqueues the build+deploy as an operation and answers
+// 202 at once, because a request has to finish inside the ALB's 60s and an image build runs
+// minutes; the wait is ours, one short GET at a time. Two gates on the lane with the mint, the
+// same as the flyctl lane. Returns null when an approval is pending.
+//
+// The operation is idempotent on (target, archive, build kind), so a re-run after approving finds
+// the one it already started rather than building again: same image, same result, no second
+// approval for a build that already happened.
+export async function deployArchive(api, projectId, ref, branch, opts, now = Date.now, wait = sleep, log = () => { }) {
+    const started = await api.rawRequest('POST', `/projects/${projectId}/archive-deploys`, {
+        branch,
+        group: opts.group,
+        archive: ref,
+        port: opts.port ? Number(opts.port) : undefined,
+        websocket: typeof opts.websocket === 'boolean' ? opts.websocket : undefined,
+        replaceSource: opts.replaceSource === true ? true : undefined,
+    });
+    // An approval is a 202 too, told apart by its status word; anything else here is our operation.
+    if (handleApproval(started, opts.json))
+        return null;
+    const operationId = started.body?.operationId;
+    if (typeof operationId !== 'string' || !operationId)
+        throw new Error('the platform accepted the deploy but returned no operation id — re-run the deploy');
+    if (started.body?.resumed === true)
+        log('resuming the deploy this archive already started');
+    const deadline = now() + DEPLOY_DEADLINE_MS;
+    const overdue = () => new Error(`the deploy did not finish within ${Math.round(DEPLOY_DEADLINE_MS / 60000)} minutes — check \`insta status\` or re-run`);
+    let last = '';
+    for (;;) {
+        // The deadline bounds the wall clock, not the number of answers: it is checked before each poll,
+        // and each poll is itself bounded by what remains, so a stalled endpoint cannot hold the CLI
+        // past it, and an answer that would arrive after it is not waited for.
+        const remaining = deadline - now();
+        if (remaining <= 0)
+            throw overdue();
+        const res = await api.rawRequest('GET', `/projects/${projectId}/archive-deploys/${encodeURIComponent(operationId)}`, undefined, {
+            signal: AbortSignal.timeout(Math.min(remaining, POLL_REQUEST_TIMEOUT_MS)),
+        }).catch((e) => {
+            if (!isAbort(e))
+                throw e;
+            throw remaining <= POLL_REQUEST_TIMEOUT_MS ? overdue() : new Error(`the platform did not answer a status poll within ${POLL_REQUEST_TIMEOUT_MS / 1000}s — check \`insta status\` or re-run`);
+        });
+        const state = res.body?.state;
+        // A failed operation is an ANSWER, not a transport error: the poll worked, and the sentence
+        // it carries (usually the gateway's own, e.g. "no Dockerfile at ./api") is the one to show.
+        if (state === 'failed') {
+            // `||` would let a non-string through and the CLI would print "[object Object]" for the one
+            // sentence that explains the failure. Only a non-empty string is a message.
+            const error = res.body?.error;
+            return { failed: typeof error === 'string' && error ? error : 'the deploy failed' };
+        }
+        if (state === 'live') {
+            const image = res.body?.imageRef;
+            const url = res.body?.url;
+            if (typeof image !== 'string' || !image || typeof url !== 'string' || !url) {
+                throw new Error('the deploy finished but the platform returned no image or URL for it — check `insta status`');
+            }
+            // Optional strings, validated as such. String() would have coerced a protocol error into a
+            // plausible-looking branch or group and reported a target the deploy never named. An omitted
+            // field falls back to what was requested; a field of the wrong type is a broken contract.
+            const optionalString = (field, v) => {
+                if (v === undefined || v === null)
+                    return undefined;
+                if (typeof v !== 'string')
+                    throw new Error(`the platform returned a non-string ${field} for the deploy — upgrade with \`insta upgrade\``);
+                return v;
+            };
+            return {
+                image, url,
+                branch: optionalString('branch', res.body.branch) ?? branch,
+                group: optionalString('group', res.body.group) ?? opts.group ?? '',
+                machineId: optionalString('machineId', res.body.machineId),
+            };
+        }
+        // Only the platform's own in-flight states keep the loop going. An absent or unknown state
+        // would otherwise spend the whole deadline looking like a slow build.
+        if (state !== 'queued' && state !== 'building' && state !== 'deploying') {
+            throw new Error(`the platform reported an unknown deploy state (${JSON.stringify(state)}) — upgrade with \`insta upgrade\``);
+        }
+        if (state !== last) {
+            log(state === 'deploying' ? 'image built, deploying it' : `${state}…`);
+            last = state;
+        }
+        await wait(POLL_MS);
+    }
+}
+//# sourceMappingURL=deploy-archive.js.map

package/dist/env.js

@@ -2,12 +2,12 @@ export const ENVS = {
     prod: {
         api: 'https://api.instacloud.com',
         mcp: 'https://mcp.instacloud.com/mcp',
-        skills: 'InsForge/insta-skills',
+        skills: 'InsForge/instacloud-skills',
     },
     staging: {
         api: 'https://api.staging.instacloud.com',
         mcp: 'https://mcp.staging.instacloud.com/mcp',
-        skills: 'InsForge/insta-skills#devel',
+        skills: 'InsForge/instacloud-skills#devel',
     },
 };
 export const DEFAULT_ENV = 'prod';

package/dist/index.js

@@ -208,13 +208,13 @@ 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 (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')
+program.command('build [dir]').description('Verify a source directory would build before deploying: detection plan + the Dockerfile (yours, or the one nixpacks would generate server-side) + 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')
     .action(guard((dir, o) => build(dir, o)));
 // ---- deploy ----
-program.command('deploy [dir]').description('Deploy a source directory (built remotely on Fly) or a prebuilt --image to a branch compute group')
+program.command('deploy [dir]').description('Deploy a source directory (built remotely; on insta-compute a Dockerfile is optional and nixpacks detects the runtime) or a prebuilt --image to a branch compute group')
     .option('--image <url>', 'prebuilt container image to deploy (instead of a source dir)').option('--branch <b>').option('--group <g>').option('--port <p>')
     .option('--websocket', 'run a WebSocket app (larger guest + connection-based concurrency)')
     .option('--replace-source', 'the service deploys from a connected GitHub repo: switch it to this image and remove the repo connection (admin); without it such a deploy is refused')

package/dist/pack-ignore.js

@@ -0,0 +1,267 @@
+import { posix } from 'node:path';
+import ignore from 'ignore';
+export function compileIgnore(files, flavour) {
+    return flavour === 'git' ? compileGit(files) : compileDocker(files);
+}
+// ---- git ----
+const depth = (base) => (base === '' ? 0 : base.split('/').length);
+// One matcher per .gitignore, each asked only about the paths beneath its own directory and
+// spelled relative to it, the way git reads them. Shallower files are consulted first, so a deeper
+// file's last matching rule wins, which is gitignore's precedence, and a file with no matching
+// rule leaves the verdict where the previous file put it.
+//
+// Case-sensitive on purpose. The package defaults to ignorecase, git itself follows
+// core.ignorecase, which differs between a macOS laptop and the Linux box that extracts the
+// archive. One tree has to pack to one identity everywhere, so the rule is the Linux one.
+function compileGit(files) {
+    const scoped = [...files]
+        .sort((a, b) => depth(a.base) - depth(b.base))
+        .map((f) => ({ base: f.base, ig: ignore({ ignorecase: false }).add(f.text) }));
+    return {
+        excludes(relPath, isDir) {
+            let excluded = false;
+            for (const { base, ig } of scoped) {
+                const sub = base === '' ? relPath : relPath.startsWith(base + '/') ? relPath.slice(base.length + 1) : '';
+                if (sub === '')
+                    continue;
+                // A trailing slash is how the package is told the path is a directory, for `logs/` rules.
+                const verdict = ig.test(isDir ? sub + '/' : sub);
+                if (verdict.ignored)
+                    excluded = true;
+                else if (verdict.unignored)
+                    excluded = false;
+            }
+            return excluded;
+        },
+        // git cannot re-include under an excluded directory, so there is never a reason to descend.
+        canPrune: () => true,
+    };
+}
+const escapeLiteral = (c) => c.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+// The rest of a pattern carries no glob syntax, so docker's fast paths apply to it.
+const plain = (rest) => !/[*?[\]\\]/.test(rest);
+// Glob to RegExp the way moby/patternmatcher compiles one (its compile(), read line by line):
+// `*` and `?` stop at a separator; a `**` is an optional run of whole directories, `(.*/)?`, and
+// the slash right after it is eaten with it, wherever it stands, so `a**/b` and `foo**bar` both
+// reach `ab`/`foobar` at the root and `a/x/b`/`foo/x/bar` below, and neither reaches `fooXbar`.
+// Two fast paths are broader than that regex and are matched exactly: a pattern that is `**` plus
+// plain text is a suffix match (`**foo` takes `xfoo`), and one ending in `**` is a prefix match.
+// Reading every interior `**` as `.*` excluded `fooXbar`, a file a local docker build keeps.
+function translate(p) {
+    let out = '';
+    let i = 0;
+    while (i < p.length) {
+        if (p.startsWith('**', i)) {
+            if (p.charAt(i + 2) === '/') {
+                out += '(?:.*/)?'; // any number of directories, including none; the slash goes with it
+                i += 3;
+            }
+            else if (i + 2 === p.length) {
+                // Trailing: bare `**` is everything, `foo**` a prefix match. `abc/**` is everything INSIDE
+                // abc and NOT abc itself: making the suffix optional matched the directory too, and a rule
+                // that reads as "drop this tree but keep one file" then dropped the file with it.
+                out += i > 0 && p.charAt(i - 1) === '/' ? '.+' : '.*';
+                i += 2;
+            }
+            else if (i === 0 && plain(p.slice(2))) {
+                out += '.*'; // docker's suffixMatch: `**foo` is "ends with foo"
+                i += 2;
+            }
+            else {
+                out += '(?:.*/)?';
+                i += 2;
+            }
+        }
+        else if (p.charAt(i) === '*') {
+            out += '[^/]*';
+            i += 1;
+        }
+        else if (p.charAt(i) === '?') {
+            out += '[^/]';
+            i += 1;
+        }
+        else if (p.charAt(i) === '[') {
+            const cls = bracket(p, i);
+            if (cls) {
+                out += cls.re;
+                i = cls.end;
+            }
+            else {
+                out += '\\[';
+                i += 1;
+            }
+        }
+        else if (p.charAt(i) === '\\' && i + 1 < p.length) {
+            // Escape: the next character is data, not a wildcard. Go's filepath.Match honours it.
+            out += escapeLiteral(p.charAt(i + 1));
+            i += 2;
+        }
+        else {
+            out += escapeLiteral(p.charAt(i));
+            i += 1;
+        }
+    }
+    return out;
+}
+// Escape members, including an explicitly escaped hyphen. bracket() preserves raw range hyphens.
+const escapeInClass = (c) => ('\\][^-'.includes(c) ? '\\' + c : c);
+// Go/RE2's POSIX classes are ASCII, not JavaScript's Unicode \s/\w or locale-dependent classes.
+// https://pkg.go.dev/regexp/syntax#hdr-Syntax
+const POSIX_CLASSES = {
+    alnum: '0-9A-Za-z', alpha: 'A-Za-z', ascii: '\\x00-\\x7f', blank: '\\t ',
+    cntrl: '\\x00-\\x1f\\x7f', digit: '0-9', graph: '\\x21-\\x7e', lower: 'a-z',
+    print: '\\x20-\\x7e', punct: '\\x21-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\x7e',
+    space: '\\t\\n\\v\\f\\r ', upper: 'A-Z', word: '0-9A-Za-z_', xdigit: '0-9A-Fa-f',
+};
+function posixClass(name, negated) {
+    const body = Object.hasOwn(POSIX_CLASSES, name) ? POSIX_CLASSES[name] : undefined;
+    if (body === undefined)
+        throw new Error('unsupported POSIX class in .dockerignore: ' + name);
+    if (!negated)
+        return body;
+    // A complemented named class can be mixed with other members inside [...]. Expand its
+    // ranges instead of nesting a negated JS class, which would silently change the grammar.
+    const member = new RegExp('[' + body + ']', 'u');
+    const point = (n) => '\\u{' + n.toString(16) + '}';
+    const range = (a, b) => a === b ? point(a) : point(a) + '-' + point(b);
+    let out = '';
+    let start = 0;
+    for (let c = 0; c < 128; c++) {
+        if (!member.test(String.fromCodePoint(c)))
+            continue;
+        if (start < c)
+            out += range(start, c - 1);
+        start = c + 1;
+    }
+    return out + range(start, 0x10ffff);
+}
+// A bracket expression starting at p[start], or null when no `]` closes it and the `[` is a
+// literal. docker hands the class to Go's regexp: a `]` right after the opening `[` (or after
+// the `^`) is a MEMBER, not the close, `\` quotes the next character, and only `^` negates, so a
+// `!` is an ordinary member. Unlike `*` and `?`, these Go regexp classes CAN match a separator.
+// Verified against moby/patternmatcher compile() on 2026-09-11: it preserves bracket expressions
+// without adding a separator exclusion (private[^x]token matches private/token).
+function bracket(p, start) {
+    let j = start + 1;
+    let negated = false;
+    if (p.charAt(j) === '^') {
+        negated = true;
+        j += 1;
+    }
+    let body = '';
+    let first = true;
+    while (j < p.length) {
+        const c = p.charAt(j);
+        if (c === ']' && !first)
+            return { re: `[${negated ? '^' : ''}${body}]`, end: j + 1 };
+        first = false;
+        if (p.startsWith('[:', j)) {
+            const named = /^\[:(\^?)([a-z]+):\]/.exec(p.slice(j));
+            if (!named)
+                throw new Error('invalid POSIX class in .dockerignore');
+            body += posixClass(named[2], named[1] === '^');
+            j += named[0].length;
+            continue;
+        }
+        if (c === '\\' && j + 1 < p.length) {
+            body += escapeInClass(p.charAt(j + 1));
+            j += 2;
+            continue;
+        }
+        body += c === '-' ? c : escapeInClass(c);
+        j += 1;
+    }
+    return null;
+}
+// Wildcard-free head of a pattern; empty means it could match anywhere. Escape-aware for the same
+// reason translate() is: `\*` is a literal star, so a head stopping at it would prune the wrong
+// tree, and the head must be UNESCAPED because it is compared against real path text.
+function literalHead(full) {
+    let out = '';
+    for (let i = 0; i < full.length; i++) {
+        const c = full.charAt(i);
+        if (c === '\\' && i + 1 < full.length) {
+            out += full.charAt(i + 1);
+            i += 1;
+            continue;
+        }
+        if (c === '*' || c === '?' || c === '[')
+            return out;
+        out += c;
+    }
+    return out;
+}
+// Docker's own preprocessing, in its order (moby/patternmatcher ReadAll): the comment test runs
+// BEFORE trimming, so `  #x` is a pattern and not a comment, and every surviving pattern goes
+// through filepath.Clean. Clean is the part that matters most here: it resolves `foo/../secrets`
+// to `secrets` and DROPS a trailing slash, so `secrets/` excludes a file named `secrets` too.
+// Treating that slash as directory-only, the way git does, under-excludes exactly the shape a
+// user writes when they mean "keep this out".
+function cleanDockerPattern(pat) {
+    const normalized = posix.normalize(pat);
+    const cut = normalized.length > 1 ? normalized.replace(/\/+$/, '') : normalized;
+    return cut === '' ? '.' : cut;
+}
+function compileDocker(files) {
+    const rules = [];
+    for (const f of files) {
+        // A UTF-8 BOM belongs to the FILE, not to its first pattern: without stripping it a
+        // BOM-prefixed `secrets.env` silently matches nothing.
+        const text = f.text.charCodeAt(0) === 0xfeff ? f.text.slice(1) : f.text;
+        for (const raw of text.split('\n')) {
+            const noEol = raw.replace(/\r+$/, '');
+            // Comment test first, untrimmed, then trim: docker's order, not ours.
+            if (noEol.startsWith('#'))
+                continue;
+            let pat = noEol.trim();
+            if (!pat)
+                continue;
+            const negated = pat.startsWith('!');
+            if (negated)
+                pat = pat.slice(1).trim();
+            if (!pat)
+                continue;
+            pat = cleanDockerPattern(pat);
+            if (pat === '.')
+                continue;
+            // Every pattern is anchored to the context root, slash or not.
+            if (pat.startsWith('/'))
+                pat = pat.slice(1);
+            if (!pat)
+                continue;
+            // The base is a real DIRECTORY NAME, not pattern syntax, so it is escaped as a literal and
+            // joined at the regex level, and prefixed to the prune head the same way, since that head
+            // is compared against real path text.
+            const prefix = f.base ? escapeLiteral(f.base) + '/' : '';
+            const head = f.base ? `${f.base}/${literalHead(pat)}` : literalHead(pat);
+            // Go matches runes: without Unicode mode, ? consumes half of a non-BMP filename,
+            // letting files the user excluded into the uploaded archive.
+            rules.push({ re: new RegExp('^' + prefix + translate(pat) + '$', 'u'), negated, literal: head });
+        }
+    }
+    // A rule matching an ancestor excludes the path too: excluding a dir excludes its contents.
+    const hits = (r, path) => {
+        if (r.re.test(path))
+            return true;
+        const parts = path.split('/');
+        for (let i = 1; i < parts.length; i++)
+            if (r.re.test(parts.slice(0, i).join('/')))
+                return true;
+        return false;
+    };
+    const negations = rules.filter((r) => r.negated);
+    return {
+        excludes(relPath) {
+            let excluded = false;
+            for (const r of rules)
+                if (hits(r, relPath))
+                    excluded = !r.negated; // last match wins
+            return excluded;
+        },
+        // docker can re-include under an excluded directory, so prune only where no negation reaches.
+        canPrune(dirPath) {
+            return !negations.some((r) => r.literal === '' || r.literal.startsWith(dirPath + '/') || dirPath.startsWith(r.literal));
+        },
+    };
+}
+//# sourceMappingURL=pack-ignore.js.map

package/dist/pack.js

@@ -0,0 +1,229 @@
+import { readdirSync, readFileSync, lstatSync, readlinkSync, existsSync, openSync, closeSync, fstatSync, constants } from 'node:fs';
+import { join, sep } from 'node:path';
+import { createHash } from 'node:crypto';
+// Not node:zlib. The digest of this archive IS its identity: the id the object is stored under,
+// the dedup key, and part of the approval-bound deploy body. The runtime's zlib is native and its
+// output differs between the runtimes this CLI ships on -- the same tree packs to 360 bytes under
+// Node 25 and 353 under Bun -- so with it the identity of a tree changed with the install channel.
+// fflate is pure JS: same algorithm, same bytes, everywhere.
+//
+// PINNED EXACTLY in package.json, not caret-ranged, and that is load-bearing rather than tidy.
+// A compiled binary bundles whatever the lockfile resolved, while `npx insta` resolves the range
+// afresh against the registry. A patch release is free to emit different valid gzip for the same
+// input, so a caret would let the two channels produce different digests for one tree -- exactly
+// the property this dependency was taken on to guarantee.
+import { gzipSync } from 'fflate';
+import { compileIgnore } from './pack-ignore.js';
+export const ARCHIVE_LIMITS = {
+    maxArchiveBytes: 256 * 1024 * 1024,
+    maxExtractedBytes: 1024 * 1024 * 1024,
+    maxFiles: 10000,
+};
+const BLOCK = 512;
+const PAD = Buffer.alloc(BLOCK, 0);
+// Only the exec bit matters: normalising to 0644 breaks entrypoints, raw mode leaks the umask.
+const fileMode = (mode) => (mode & 0o111 ? 0o755 : 0o644);
+const octal = (n, width) => n.toString(8).padStart(width - 1, '0') + '\0';
+// ustar splits a long path across prefix(155) + name(100); refuse by name rather than truncate.
+function splitName(path) {
+    if (Buffer.byteLength(path) <= 100)
+        return { name: path, prefix: '' };
+    for (let i = path.indexOf('/'); i !== -1; i = path.indexOf('/', i + 1)) {
+        const prefix = path.slice(0, i);
+        const name = path.slice(i + 1);
+        if (Buffer.byteLength(prefix) <= 155 && Buffer.byteLength(name) <= 100)
+            return { name, prefix };
+    }
+    throw new Error(`path too long for a tar archive: ${path}`);
+}
+function header(path, mode, size, type) {
+    const h = Buffer.alloc(BLOCK, 0);
+    const { name, prefix } = splitName(path);
+    h.write(name, 0, 100, 'utf8');
+    h.write(octal(mode, 8), 100, 8, 'ascii');
+    h.write(octal(0, 8), 108, 8, 'ascii'); // uid, pinned
+    h.write(octal(0, 8), 116, 8, 'ascii'); // gid, pinned
+    h.write(octal(size, 12), 124, 12, 'ascii');
+    h.write(octal(0, 12), 136, 12, 'ascii'); // mtime, pinned
+    h.write('        ', 148, 8, 'ascii'); // checksum is summed as spaces, then overwritten
+    h.write(type, 156, 1, 'ascii');
+    h.write('ustar\0', 257, 6, 'ascii');
+    h.write('00', 263, 2, 'ascii');
+    h.write(prefix, 345, 155, 'utf8');
+    let sum = 0;
+    for (const b of h)
+        sum += b;
+    h.write(octal(sum, 7) + ' ', 148, 8, 'ascii');
+    return h;
+}
+// The builder fails the whole build on a symlink entry; hardlinks are fine, we only write type '0'.
+function linkError(links) {
+    const shown = links.slice(0, 5).map((l) => `  ${l.path} -> ${l.target}`);
+    const more = links.length > shown.length ? [`  … and ${links.length - shown.length} more`] : [];
+    return new Error([
+        'a deploy archive cannot contain symlinks — the build gateway rejects them:',
+        ...shown,
+        ...more,
+        'replace them with real files, or exclude them (.dockerignore, or .gitignore when there is no .dockerignore)',
+    ].join('\n'));
+}
+// .git blows the 10k entry cap on its own; .insta is CLI state. A deliberate departure from docker.
+const ALWAYS_SKIP = new Set(['.git', '.insta']);
+// docker keeps these whatever the ignore file says; avoids a remote-only "Dockerfile not found".
+const KEPT_AT_ROOT = new Set(['Dockerfile', '.dockerignore']);
+// One global sort emits a parent before its children, since a dir name prefixes everything inside.
+function walk(root, rel, out, links, ig, files, flavour) {
+    const dirAbs = join(root, rel === '' ? '.' : rel.split('/').join(sep));
+    const names = readdirSync(dirAbs).sort();
+    // A nested .gitignore extends its own subtree; recompiled only where one exists. docker has none.
+    if (flavour === 'git' && rel !== '' && names.includes('.gitignore')) {
+        files = [...files, { base: rel, text: readFileSync(join(dirAbs, '.gitignore'), 'utf8') }];
+        ig = compileIgnore(files, 'git');
+    }
+    for (const name of names) {
+        if (ALWAYS_SKIP.has(name))
+            continue;
+        const relPath = rel === '' ? name : `${rel}/${name}`;
+        const keep = rel === '' && KEPT_AT_ROOT.has(name);
+        const abs = join(root, relPath.split('/').join(sep));
+        const st = lstatSync(abs);
+        if (st.isSymbolicLink()) {
+            // An ignored symlink is not the user's problem to solve.
+            if (!keep && ig.excludes(relPath, false))
+                continue;
+            links.push({ path: relPath, target: readlinkSync(abs) });
+        }
+        else if (st.isDirectory()) {
+            if (ig.excludes(relPath, true) && ig.canPrune(relPath))
+                continue;
+            // Emitted whenever we descend, so a re-included child has its parent.
+            out.push({ path: `${relPath}/`, mode: 0o755, size: 0, dir: true });
+            walk(root, relPath, out, links, ig, files, flavour);
+        }
+        else if (st.isFile()) {
+            if (!keep && ig.excludes(relPath, false))
+                continue;
+            out.push({ path: relPath, mode: fileMode(st.mode), size: st.size, dir: false, ino: st.ino, dev: st.dev });
+        }
+    }
+}
+// The walk classifies with lstat and the read happens later, so a plain readFileSync would
+// FOLLOW a symlink that replaced the file in between and put a file from outside the directory
+// into an archive that promises none. Two guards, and neither is a full one on its own:
+//
+//   O_NOFOLLOW refuses when the final component is a symlink AT OPEN TIME, closing the swap the
+//   walk cannot see. Undefined on Windows, where it degrades to the check below.
+//
+//   fstat on the OPEN HANDLE must still describe the file the walk measured: same inode, same
+//   device, same size. Its job is the tar's own consistency -- a file rewritten to a different
+//   length mid-pack would otherwise produce a header whose count disagrees with its payload.
+//
+// Two things neither closes, and both are stated rather than implied away:
+//
+//   An ANCESTOR directory swapped for a symlink. Node exposes no openat, so resolving each
+//   component against a directory handle is not available here.
+//
+//   A same-size plain file deleted and recreated. Measured on linux rather than assumed: the
+//   inode is REUSED and mtimeNs/ctimeNs are byte-identical for a delete+create inside one
+//   timestamp tick, so no stat-based identity can see it. It is also the least interesting case
+//   -- the symlink promise still holds, the tar stays well formed because the length did not
+//   move, and the archive simply carries a slightly newer copy of a file the caller owns.
+//
+// The residual on both is narrow: someone able to rewrite files and directories inside the tree
+// being packed can already put any bytes they like into it by writing them.
+export function readEntry(abs, e) {
+    const noFollow = constants.O_NOFOLLOW ?? 0;
+    let fd;
+    try {
+        fd = openSync(abs, constants.O_RDONLY | noFollow);
+    }
+    catch (err) {
+        if (err.code === 'ELOOP') {
+            throw new Error(`${e.path} became a symlink while packing — re-run the deploy`);
+        }
+        throw err;
+    }
+    try {
+        const st = fstatSync(fd);
+        const same = st.isFile() && st.size === e.size
+            && (e.ino === undefined || st.ino === e.ino) && (e.dev === undefined || st.dev === e.dev);
+        if (!same)
+            throw new Error(`${e.path} changed while packing — re-run the deploy`);
+        return readFileSync(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+// A root .dockerignore wins outright; merging would drop artefacts the image needs.
+function rootIgnore(absDir) {
+    const read = (name) => readFileSync(join(absDir, name), 'utf8');
+    if (existsSync(join(absDir, '.dockerignore'))) {
+        const files = [{ base: '', text: read('.dockerignore') }];
+        return { ig: compileIgnore(files, 'docker'), files, flavour: 'docker' };
+    }
+    const files = existsSync(join(absDir, '.gitignore')) ? [{ base: '', text: read('.gitignore') }] : [];
+    return { ig: compileIgnore(files, 'git'), files, flavour: 'git' };
+}
+const mib = (n) => `${(n / (1024 * 1024)).toFixed(1)} MiB`;
+// Windows has no POSIX exec bit for lstat to report, so a script packs as 0644 and the image
+// cannot run it. Same as `docker build` from Windows; say so rather than let it fail at start-up.
+export function windowsModeCaveat(platform = process.platform) {
+    if (platform !== 'win32')
+        return null;
+    return 'packing on Windows: file permissions are not preserved, so an executable script arrives as 0644 — add `RUN chmod +x <path>` to your Dockerfile if the image runs one';
+}
+export function packDirectory(absDir, limits = {}) {
+    const cap = { ...ARCHIVE_LIMITS, ...limits };
+    const found = [];
+    const links = [];
+    const { ig, files, flavour } = rootIgnore(absDir);
+    walk(absDir, '', found, links, ig, files, flavour);
+    if (links.length)
+        throw linkError(links);
+    found.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+    // Known from the walk alone, so both fail before a byte is read or compressed.
+    const extractedBytes = found.reduce((n, e) => n + e.size, 0);
+    if (found.length > cap.maxFiles) {
+        throw new Error(`archive has too many files: ${found.length} > ${cap.maxFiles} (directories count) — exclude what the build does not need`);
+    }
+    if (extractedBytes > cap.maxExtractedBytes) {
+        throw new Error(`archive would extract to ${mib(extractedBytes)}, over the ${mib(cap.maxExtractedBytes)} limit — exclude what the build does not need`);
+    }
+    const chunks = [];
+    for (const e of found) {
+        if (e.dir) {
+            chunks.push(header(e.path, e.mode, 0, '5'));
+            continue;
+        }
+        const data = readEntry(join(absDir, e.path.split('/').join(sep)), e);
+        chunks.push(header(e.path, e.mode, data.length, '0'), data);
+        const rem = data.length % BLOCK;
+        if (rem)
+            chunks.push(PAD.subarray(0, BLOCK - rem));
+    }
+    chunks.push(PAD, PAD); // two zero blocks close a tar
+    const tar = Buffer.concat(chunks);
+    // Drop the per-file buffers before the compressor allocates: concat has copied every byte, so
+    // holding the originals through gzip is a third full copy of the tree for nothing. This does
+    // not make the packer streaming -- the peak is still two copies plus the compressor's own
+    // working set -- but it is the part that costs nothing to give back.
+    chunks.length = 0;
+    const archive = Buffer.from(gzipSync(tar, { level: 9, mtime: 0 }));
+    // Pinned here as well as asked of the library: gzip carries its own mtime (4-7) and OS byte (9),
+    // and a header the packer writes itself cannot drift with a dependency's defaults.
+    archive.writeUInt32LE(0, 4);
+    archive[9] = 255;
+    if (archive.length > cap.maxArchiveBytes) {
+        throw new Error(`archive is too large: ${mib(archive.length)} > ${mib(cap.maxArchiveBytes)} — exclude what the build does not need`);
+    }
+    return {
+        archive,
+        sha256: createHash('sha256').update(archive).digest('hex'),
+        files: found.filter((e) => !e.dir).length,
+        entries: found.length,
+        extractedBytes,
+        hasDockerfile: found.some((e) => e.path === 'Dockerfile'),
+    };
+}
+//# sourceMappingURL=pack.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "insta",
-  "version": "0.0.68",
+  "version": "0.0.69",
   "type": "module",
   "description": "InstaCloud CLI — a thin client of the platform control-plane API.",
   "keywords": [
@@ -12,13 +12,13 @@
     "platform"
   ],
   "license": "Apache-2.0",
-  "homepage": "https://github.com/InsForge/insta-cli#readme",
+  "homepage": "https://github.com/InsForge/instacloud-cli#readme",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/InsForge/insta-cli.git"
+    "url": "git+https://github.com/InsForge/instacloud-cli.git"
   },
   "bugs": {
-    "url": "https://github.com/InsForge/insta-cli/issues"
+    "url": "https://github.com/InsForge/instacloud-cli/issues"
   },
   "bin": {
     "insta": "dist/index.js"
@@ -44,6 +44,8 @@
   "dependencies": {
     "@clack/prompts": "^0.9.1",
     "commander": "^12.1.0",
+    "fflate": "0.8.3",
+    "ignore": "7.0.9",
     "yaml": "^2.9.0"
   },
   "devDependencies": {