insta 0.0.68 → 0.0.70

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.70",
   "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": {