zyrk 0.3.7 → 0.3.9

package/dist/commands/maintenance.js

@@ -0,0 +1,198 @@
+/** Read-only advisory reporting and verified source prefetch. */
+import { readFile } from "node:fs/promises";
+import * as path from "node:path";
+import { json as fetchJson } from "npm-registry-fetch";
+import { satisfies, validRange } from "semver";
+import { ZyrkError } from "../errors.js";
+import { installProject } from "../install/run.js";
+import { readLockfile, assertFrozenCompatible } from "../lockfile/read.js";
+import { manifestFingerprint, configFingerprint, scriptPolicyFingerprint, } from "../lockfile/fingerprints.js";
+import { lockedGraph, lockMismatch } from "../install/lock.js";
+const severities = ["info", "low", "moderate", "high", "critical"];
+function object(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function usage(reason) {
+    return new ZyrkError("ZYRK_USAGE", `Cannot run maintenance: ${reason}.`, {
+        remedy: "Use audit [--audit-level <severity>] [--offline], or fetch --frozen-lockfile [--offline].",
+    });
+}
+export async function runMaintenanceCommand(options) {
+    let frozen = false, offline = false;
+    let threshold;
+    for (let i = 0; i < options.args.length; i++) {
+        const arg = options.args[i];
+        if (arg === "--offline")
+            offline = true;
+        else if (arg === "--frozen-lockfile" && options.command === "fetch")
+            frozen = true;
+        else if (arg === "--audit-level" && options.command === "audit") {
+            threshold = options.args[++i];
+            if (threshold === undefined)
+                throw usage("--audit-level requires a severity");
+        }
+        else if (arg.startsWith("--audit-level=") && options.command === "audit")
+            threshold = arg.slice(14);
+        else
+            throw usage("an unsupported option or argument was supplied");
+    }
+    if (options.command === "repair")
+        throw new ZyrkError("ZYRK_STORE_CORRUPT", "Cannot repair shared content in place while other projects may reference it.", {
+            remedy: "Use store verify to identify affected sources; immutable replacement and reverse-closure repair are not available yet.",
+        });
+    if (options.command === "fetch") {
+        if (!frozen)
+            throw usage("fetch requires --frozen-lockfile");
+        return installProject({
+            projectDir: options.projectDir,
+            store: options.store,
+            registry: options.registry,
+            frozen: true,
+            offline,
+            fetchOnly: true,
+        });
+    }
+    let manifest;
+    try {
+        manifest = JSON.parse(await readFile(path.join(options.projectDir, "package.json"), "utf8"));
+    }
+    catch {
+        throw new ZyrkError("ZYRK_MANIFEST_INVALID", "Cannot audit dependencies without a readable package.json.", { remedy: "Restore the project manifest and retry." });
+    }
+    if (!object(manifest))
+        throw usage("package.json must be an object");
+    const config = object(manifest.zyrk) ? manifest.zyrk.audit : undefined;
+    if (config !== undefined &&
+        (!object(config) ||
+            Object.keys(config).some((key) => !["enabled", "failOn"].includes(key)) ||
+            (config.enabled !== undefined && typeof config.enabled !== "boolean") ||
+            (config.failOn !== undefined && typeof config.failOn !== "string")))
+        throw new ZyrkError("ZYRK_POLICY_DENIED", "Cannot audit dependencies with unsupported audit policy settings.", {
+            remedy: "Set package.json zyrk.audit to enabled (boolean) and failOn (none, info, low, moderate, high, or critical).",
+        });
+    const policy = object(config) ? config : {};
+    threshold ??= typeof policy.failOn === "string" ? policy.failOn : "none";
+    if (threshold !== "none" && !severities.includes(threshold))
+        throw usage("audit severity threshold is invalid");
+    const base = {
+        kind: "audit",
+        status: "complete",
+        advisories: [],
+        thresholdExceeded: false,
+        warnings: [],
+    };
+    if (policy.enabled === false)
+        return {
+            ...base,
+            status: "disabled",
+            warnings: [
+                "Audit is disabled by project policy; no dependency information was sent.",
+            ],
+        };
+    if (offline)
+        return {
+            ...base,
+            status: "unavailable",
+            warnings: [
+                "Offline audit has no cached advisory data; vulnerability status is unknown.",
+            ],
+        };
+    const lock = await readLockfile(path.join(options.projectDir, "package-lock.json"));
+    if (!lock?.doc.zyrk)
+        throw lockMismatch("audit requires an exact zyrk lockfile");
+    assertFrozenCompatible(lock.doc, {
+        manifest: manifestFingerprint(manifest),
+        scripts: scriptPolicyFingerprint(object(manifest.zyrk) ? manifest.zyrk.scripts : undefined),
+        config: configFingerprint({
+            registry: options.registry.origin,
+            linker: "shared",
+        }),
+    });
+    const graph = lockedGraph(lock.doc);
+    const packages = Object.create(null);
+    for (const node of graph.nodes) {
+        if (node.origin !== options.registry.origin)
+            throw new ZyrkError("ZYRK_POLICY_DENIED", "Cannot audit a graph from a different registry origin.", {
+                remedy: "Select the registry recorded by the lockfile before sending dependency names.",
+            });
+        packages[node.name] ??= [];
+        if (!packages[node.name].includes(node.version))
+            packages[node.name].push(node.version);
+    }
+    if (!graph.nodes.length)
+        return base;
+    let response;
+    try {
+        response = await fetchJson(new URL("-/npm/v1/security/advisories/bulk", options.registry.registry)
+            .href, {
+            method: "POST",
+            body: packages,
+            registry: options.registry.registry,
+            retry: false,
+            timeout: 15_000,
+            headers: { "content-type": "application/json" },
+        });
+    }
+    catch {
+        return {
+            ...base,
+            status: "unavailable",
+            warnings: [
+                "The configured registry advisory service is unavailable; vulnerability status is unknown.",
+            ],
+        };
+    }
+    const unavailable = () => ({
+        ...base,
+        status: "unavailable",
+        warnings: [
+            "The configured advisory service returned unsupported data; vulnerability status is unknown.",
+        ],
+    });
+    if (!object(response))
+        return unavailable();
+    for (const [name, entries] of Object.entries(response)) {
+        if (!Object.hasOwn(packages, name) || !Array.isArray(entries))
+            return unavailable();
+        for (const entry of entries) {
+            if (!object(entry) ||
+                typeof entry.severity !== "string" ||
+                !severities.includes(entry.severity) ||
+                typeof entry.vulnerable_versions !== "string" ||
+                validRange(entry.vulnerable_versions) === null ||
+                typeof entry.title !== "string" ||
+                typeof entry.url !== "string")
+                return unavailable();
+            let url;
+            try {
+                url = new URL(entry.url);
+            }
+            catch {
+                return unavailable();
+            }
+            if (!["https:", "http:"].includes(url.protocol) ||
+                url.username ||
+                url.password)
+                return unavailable();
+            for (const version of packages[name])
+                if (satisfies(version, entry.vulnerable_versions))
+                    base.advisories.push({
+                        name,
+                        version,
+                        severity: entry.severity,
+                        title: entry.title
+                            .replace(/[\u0000-\u001f\u007f]/g, " ")
+                            .slice(0, 500),
+                        url: url.href,
+                    });
+        }
+    }
+    base.advisories.sort((a, b) => a.name.localeCompare(b.name) ||
+        a.version.localeCompare(b.version) ||
+        a.title.localeCompare(b.title));
+    base.thresholdExceeded =
+        threshold !== "none" &&
+            base.advisories.some((advisory) => severities.indexOf(advisory.severity) >=
+                severities.indexOf(threshold));
+    return base;
+}

package/dist/commands/patch.d.ts

@@ -0,0 +1,38 @@
+import { Store } from "../store/layout.ts";
+type Change = {
+    path: string;
+    before: string | null;
+    content: string | null;
+    executable: boolean;
+};
+export type ProjectPatch = {
+    schemaVersion: 1;
+    sourceId: string;
+    manifestHash: string;
+    changes: Change[];
+};
+export type LoadedProjectPatch = ProjectPatch & {
+    digest: string;
+    artifact: string;
+};
+export declare function loadProjectPatches(project: string): Promise<LoadedProjectPatch[]>;
+export declare function hasProjectPatches(project: string): Promise<boolean>;
+/** Caller supplies the complete private generation, copied/reflinked without store hardlinks. */
+export declare function applyProjectPatches(options: {
+    project: string;
+    packages: ReadonlyMap<string, {
+        sourceId: string;
+        directory: string;
+    }>;
+}): Promise<{
+    digest: string;
+    count: number;
+}>;
+export declare function runPatchCommand(options: {
+    command: "patch" | "patch-commit";
+    args: readonly string[];
+    store: Store;
+    cwd: string;
+}): Promise<unknown>;
+export {};
+//# sourceMappingURL=patch.d.ts.map

package/dist/commands/patch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patch.d.ts","sourceRoot":"","sources":["../../src/commands/patch.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAS3C,KAAK,MAAM,GAAG;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AACF,MAAM,MAAM,YAAY,GAAG;IACzB,aAAa,EAAE,CAAC,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AACF,MAAM,MAAM,kBAAkB,GAAG,YAAY,GAAG;IAC9C,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AA+DF,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,kBAAkB,EAAE,CAAC,CA+C/B;AACD,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAEzE;AAED,iGAAiG;AACjG,wBAAsB,mBAAmB,CAAC,OAAO,EAAE;IACjD,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACxE,GAAG,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAgD7C;AAED,wBAAsB,eAAe,CAAC,OAAO,EAAE;IAC7C,OAAO,EAAE,OAAO,GAAG,cAAc,CAAC;IAClC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACxB,KAAK,EAAE,KAAK,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;CACb,GAAG,OAAO,CAAC,OAAO,CAAC,CAsBnB"}

package/dist/commands/patch.js

@@ -0,0 +1,336 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { ZyrkError } from "../errors.js";
+import { lockedGraph } from "../install/lock.js";
+import { Store } from "../store/layout.js";
+import { readSourceManifest } from "../store/manifests.js";
+import { objectPathFor, verifyObjectPayload } from "../store/objects.js";
+import { isErrno, writeFileAtomic } from "../util/fsx.js";
+import { modeClassOf, sha512Hex } from "../util/hash.js";
+import { canonicalJson } from "../util/json.js";
+import { randomId } from "../util/ids.js";
+import { acquireLock } from "../util/locks.js";
+function fail(why) {
+    throw new ZyrkError("ZYRK_MANIFEST_INVALID", `Cannot process dependency patch: ${why}.`, {
+        remedy: "Use a patch editing area created by zyrk, keep changes inside the intended package, and reinstall after committing the patch.",
+    });
+}
+function relative(value) {
+    if (!value ||
+        value.includes("\\") ||
+        path.posix.isAbsolute(value) ||
+        value.split("/").some((part) => !part || part === "." || part === ".."))
+        fail("unsafe package-relative path");
+    return value;
+}
+async function readJson(file) {
+    if (!(await fs.lstat(file)).isFile())
+        fail("metadata is not a regular file");
+    try {
+        return JSON.parse(await fs.readFile(file, "utf8"));
+    }
+    catch {
+        return fail("invalid JSON metadata");
+    }
+}
+async function manifest(project) {
+    return (await readJson(path.join(project, "package.json")));
+}
+async function safeParent(root, relativePath, create) {
+    relative(relativePath);
+    let current = root;
+    if (!(await fs.lstat(root)).isDirectory())
+        fail("package root is not a real directory");
+    for (const segment of relativePath.split("/").slice(0, -1)) {
+        current = path.join(current, segment);
+        try {
+            if (!(await fs.lstat(current)).isDirectory())
+                fail("path crosses a link or file");
+        }
+        catch (error) {
+            if (!create || !isErrno(error, "ENOENT"))
+                throw error;
+            await fs.mkdir(current, { mode: 0o700 });
+        }
+    }
+    return path.join(root, ...relativePath.split("/"));
+}
+function scanSecrets(bytes) {
+    const text = bytes.toString("utf8");
+    if (/-----BEGIN (?:[A-Z ]+ )?PRIVATE KEY-----|\bnpm_[A-Za-z0-9]{20,}|\bgh[pousr]_[A-Za-z0-9]{20,}|https?:\/\/[^\s/@]+:[^\s/@]+@/.test(text))
+        fail("patch contains credential-like content");
+}
+export async function loadProjectPatches(project) {
+    const config = (await manifest(project)).zyrk?.patches;
+    if (config === undefined)
+        return [];
+    if (!config || typeof config !== "object" || Array.isArray(config))
+        fail("zyrk.patches must map source identities to artifact paths");
+    const result = [];
+    for (const sourceId of Object.keys(config).sort()) {
+        const artifact = config[sourceId];
+        if (typeof artifact !== "string" || !artifact.startsWith(".zyrk/patches/"))
+            fail("patch artifact must live in .zyrk/patches");
+        const file = await safeParent(project, artifact, false);
+        const raw = (await readJson(file));
+        if (!raw ||
+            raw.schemaVersion !== 1 ||
+            raw.sourceId !== sourceId ||
+            typeof raw.manifestHash !== "string" ||
+            !/^[0-9a-f]{128}$/.test(raw.manifestHash) ||
+            !Array.isArray(raw.changes))
+            fail("patch source binding is invalid");
+        const seen = new Set();
+        for (const change of raw.changes) {
+            if (!change || typeof change.path !== "string")
+                fail("invalid change");
+            relative(change.path);
+            if (seen.has(change.path))
+                fail("duplicate change");
+            seen.add(change.path);
+            if (change.before !== null &&
+                (typeof change.before !== "string" ||
+                    !/^[0-9a-f]{128}$/.test(change.before)))
+                fail("invalid original file digest");
+            if (typeof change.executable !== "boolean" ||
+                (change.content !== null &&
+                    (typeof change.content !== "string" ||
+                        Buffer.from(change.content, "base64").toString("base64") !==
+                            change.content)))
+                fail("invalid file delta");
+            if (change.content !== null)
+                scanSecrets(Buffer.from(change.content, "base64"));
+        }
+        result.push({ ...raw, artifact, digest: sha512Hex(canonicalJson(raw)) });
+    }
+    return result;
+}
+export async function hasProjectPatches(project) {
+    return (await loadProjectPatches(project)).length > 0;
+}
+/** Caller supplies the complete private generation, copied/reflinked without store hardlinks. */
+export async function applyProjectPatches(options) {
+    const project = await fs.realpath(options.project);
+    const patches = await loadProjectPatches(project);
+    let count = 0;
+    for (const patch of patches) {
+        const targets = [...options.packages.values()].filter((pkg) => pkg.sourceId === patch.sourceId);
+        if (!targets.length)
+            fail("patched source is absent from the selected graph");
+        for (const pkg of targets) {
+            const root = await fs.realpath(pkg.directory);
+            if (!root.startsWith(`${project}${path.sep}`) ||
+                !root.startsWith(path.join(project, ".zyrk") + path.sep))
+                fail("patch destination is outside the private generation");
+            for (const change of patch.changes) {
+                const target = await safeParent(root, change.path, true);
+                let before = null;
+                try {
+                    const stat = await fs.lstat(target);
+                    if (!stat.isFile() || stat.nlink > 1)
+                        fail("patch target is a link or shares an inode");
+                    before = await fs.readFile(target);
+                }
+                catch (error) {
+                    if (!isErrno(error, "ENOENT"))
+                        throw error;
+                }
+                if ((before === null ? null : sha512Hex(before)) !== change.before)
+                    fail("original file digest differs from patch");
+                if (change.content === null) {
+                    if (before !== null)
+                        await fs.unlink(target);
+                }
+                else
+                    await writeFileAtomic(target, Buffer.from(change.content, "base64"), {
+                        mode: change.executable ? 0o755 : 0o644,
+                    });
+            }
+            count++;
+        }
+    }
+    return {
+        digest: sha512Hex(canonicalJson(patches.map(({ sourceId, digest }) => ({ sourceId, digest })))),
+        count,
+    };
+}
+export async function runPatchCommand(options) {
+    if (options.args.length !== 1 || !options.args[0])
+        fail("expected one package selector or editing-area path");
+    const project = await fs.realpath(options.cwd);
+    const control = path.join(project, ".zyrk");
+    try {
+        if (!(await fs.lstat(control)).isDirectory())
+            fail("project control directory is not a real directory");
+    }
+    catch (error) {
+        if (!isErrno(error, "ENOENT"))
+            throw error;
+        await fs.mkdir(control, { mode: 0o700 });
+    }
+    const held = await acquireLock(path.join(control, "project.lock"), {
+        name: "project patch",
+    });
+    try {
+        return options.command === "patch"
+            ? await createEditingArea(project, options.args[0], options.store)
+            : await commitPatch(project, options.args[0], options.store);
+    }
+    finally {
+        await held.release();
+    }
+}
+async function createEditingArea(project, selector, store) {
+    const graph = lockedGraph((await readJson(path.join(project, "package-lock.json"))));
+    const matches = graph.nodes.filter((node) => node.name === selector ||
+        `${node.name}@${node.version}` === selector ||
+        node.key === selector);
+    const ids = [...new Set(matches.map((node) => node.sourceId))];
+    if (ids.length !== 1 || !ids[0])
+        fail("selector must identify exactly one installed source");
+    const sourceId = ids[0];
+    const doc = await readSourceManifest(store, sourceId);
+    const base = path.join(project, ".zyrk", "patch-work");
+    await safeParent(project, ".zyrk/patch-work/placeholder", true);
+    const editingArea = path.join(base, randomId("edit1_"));
+    await fs.mkdir(editingArea, { mode: 0o700 });
+    const packageRoot = path.join(editingArea, "package");
+    await fs.mkdir(packageRoot, { mode: 0o700 });
+    for (const entry of doc.manifest.entries) {
+        const target = await safeParent(packageRoot, entry.path, true);
+        if (entry.type === "dir")
+            await fs.mkdir(target, { recursive: true, mode: 0o755 });
+        else if (entry.type === "symlink")
+            await fs.symlink(entry.target, target);
+        else {
+            const object = objectPathFor(store, entry.objectId);
+            if (!(await fs.lstat(object)).isFile())
+                fail("source object is not a regular file");
+            const verified = await verifyObjectPayload(store, {
+                objectId: entry.objectId,
+                innerDigestHex: entry.innerDigest,
+                modeClass: entry.mode,
+                bytes: entry.size,
+            });
+            if (!verified.ok)
+                fail("source payload verification failed");
+            await fs.copyFile(object, target);
+            await fs.chmod(target, entry.mode === "exec" ? 0o755 : 0o644);
+        }
+    }
+    await writeFileAtomic(path.join(editingArea, "edit.json"), JSON.stringify({
+        schemaVersion: 1,
+        sourceId,
+        manifestHash: doc.manifestHash,
+    }), { mode: 0o600 });
+    return {
+        editingArea: packageRoot,
+        sourceId,
+        next: "Edit these private files, then run zyrk patch-commit <editing-area>.",
+    };
+}
+async function commitPatch(project, argument, store) {
+    let area = await fs.realpath(path.resolve(project, argument));
+    if (path.basename(area) === "package")
+        area = path.dirname(area);
+    const base = path.join(project, ".zyrk", "patch-work");
+    if (path.dirname(area) !== base)
+        fail("editing area is outside this project");
+    const info = (await readJson(path.join(area, "edit.json")));
+    if (!info ||
+        typeof info.sourceId !== "string" ||
+        !/^[a-z0-9_]+$/.test(info.sourceId))
+        fail("invalid editing source identity");
+    const original = await readSourceManifest(store, info.sourceId);
+    if (original.manifestHash !== info.manifestHash)
+        fail("source manifest changed");
+    const edited = new Map();
+    const originalEntries = new Map(original.manifest.entries.map((entry) => [entry.path, entry]));
+    const walk = async (directory, prefix) => {
+        if (!(await fs.lstat(directory)).isDirectory())
+            fail("editing root is not a real directory");
+        for (const name of (await fs.readdir(directory)).sort()) {
+            const rel = prefix ? `${prefix}/${name}` : name;
+            const full = path.join(directory, name);
+            const stat = await fs.lstat(full);
+            if (stat.isDirectory()) {
+                await walk(full, rel);
+                continue;
+            }
+            if (stat.isSymbolicLink()) {
+                const old = originalEntries.get(rel);
+                if (!old ||
+                    old.type !== "symlink" ||
+                    (await fs.readlink(full)) !== old.target)
+                    fail("symlink edits are unsupported");
+                continue;
+            }
+            if (!stat.isFile() || stat.size > 16 * 1024 * 1024)
+                fail("unsupported or oversized edited file");
+            const bytes = await fs.readFile(full);
+            scanSecrets(bytes);
+            edited.set(relative(rel), {
+                bytes,
+                executable: modeClassOf(stat.mode) === "exec",
+            });
+        }
+    };
+    await walk(path.join(area, "package"), "");
+    const changes = [];
+    for (const [name, old] of originalEntries) {
+        if (old.type === "symlink") {
+            try {
+                if (!(await fs.lstat(path.join(area, "package", ...name.split("/")))).isSymbolicLink())
+                    fail("symlink edits are unsupported");
+            }
+            catch {
+                fail("symlink edits are unsupported");
+            }
+        }
+    }
+    const files = new Set([
+        ...original.manifest.entries
+            .filter((entry) => entry.type === "file")
+            .map((entry) => entry.path),
+        ...edited.keys(),
+    ]);
+    for (const name of [...files].sort()) {
+        const old = originalEntries.get(name);
+        if (old && old.type !== "file")
+            fail("entry type changes are unsupported");
+        const next = edited.get(name);
+        const digest = next ? sha512Hex(next.bytes) : null;
+        if (old?.innerDigest === digest &&
+            (old.mode === "exec") === next?.executable)
+            continue;
+        changes.push({
+            path: name,
+            before: old?.innerDigest ?? null,
+            content: next?.bytes.toString("base64") ?? null,
+            executable: next?.executable ?? false,
+        });
+    }
+    const patch = {
+        schemaVersion: 1,
+        sourceId: info.sourceId,
+        manifestHash: info.manifestHash,
+        changes,
+    };
+    const digest = sha512Hex(canonicalJson(patch));
+    const artifact = `.zyrk/patches/${digest}.json`;
+    const file = await safeParent(project, artifact, true);
+    await writeFileAtomic(file, `${canonicalJson(patch)}\n`, { mode: 0o644 });
+    const config = await manifest(project);
+    config.zyrk = {
+        ...config.zyrk,
+        patches: { ...config.zyrk?.patches, [info.sourceId]: artifact },
+    };
+    await writeFileAtomic(path.join(project, "package.json"), `${JSON.stringify(config, null, 2)}\n`, { mode: 0o644 });
+    return {
+        artifact,
+        digest,
+        sourceId: info.sourceId,
+        changedFiles: changes.length,
+        next: "Commit the artifact and package.json, then reinstall to apply it to a private project generation.",
+    };
+}

package/dist/commands/project.d.ts

@@ -0,0 +1,15 @@
+export type ProjectCommandOptions = {
+    command: string;
+    args: readonly string[];
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    stdout: {
+        write(chunk: string): unknown;
+    };
+    stderr: {
+        write(chunk: string): unknown;
+    };
+    json?: boolean;
+};
+export declare function runProjectCommand(options: ProjectCommandOptions): Promise<number>;
+//# sourceMappingURL=project.d.ts.map

package/dist/commands/project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../src/commands/project.ts"],"names":[],"mappings":"AAiDA,MAAM,MAAM,qBAAqB,GAAG;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;IACvB,MAAM,EAAE;QAAE,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAC;IAC1C,MAAM,EAAE;QAAE,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAC;IAC1C,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB,CAAC;AA+EF,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,MAAM,CAAC,CA8KjB"}