neozip-mcp 0.1.0-beta

package/dist/archive/embed-metadata.js

@@ -0,0 +1,283 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { ZipCopyNode, crc32 } from "neozipkit/node";
+import { createTimestampMetadataEntry, submitDigest, extractTimestampData, findMetadataEntry, pollForConfirmation, shouldUpgrade, verifyDigest, } from "neozip-blockchain/token-service";
+import neoBlockchain from "neozip-blockchain";
+const { getChainIdByName, getContractConfig } = neoBlockchain;
+import { TOKENIZED_METADATA } from "neozip-blockchain";
+import { ZipkitNode } from "../neozipkit-node.js";
+import { computeMerkleRoot } from "./merkle.js";
+import { mintArchiveToken } from "./mint-archive.js";
+import { enrichTimestampMetadata } from "./timestamp-network.js";
+function createTokenMetadataZipEntry(zipkit, tokenMetadata) {
+    try {
+        const buffer = Buffer.from(JSON.stringify(tokenMetadata, null, 2), "utf-8");
+        const entry = zipkit.createZipEntry?.(TOKENIZED_METADATA);
+        if (!entry)
+            return null;
+        entry.crc = crc32(buffer);
+        entry.uncompressedSize = buffer.length;
+        entry.compressedSize = buffer.length;
+        entry.cmpMethod = 0;
+        entry.realCmpMethod = 0;
+        entry.fileBuffer = buffer;
+        entry.isMetaData = true;
+        return entry;
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeStoredMetadataEntry(entry) {
+    entry.cmpMethod = entry.cmpMethod ?? 0;
+    entry.realCmpMethod = 0;
+    if (entry.fileBuffer && Buffer.isBuffer(entry.fileBuffer)) {
+        entry.compressedSize = entry.fileBuffer.length;
+        entry.uncompressedSize = entry.fileBuffer.length;
+    }
+}
+export async function appendStoredEntries(sourcePath, outputPath, storedEntries) {
+    if (storedEntries.length === 0) {
+        throw new Error("No metadata entries to append");
+    }
+    const replaceNames = new Set(storedEntries.map((entry) => entry.filename || entry.fileName));
+    const copyNode = new ZipCopyNode();
+    const tempPath = path.join(os.tmpdir(), `neozip-mcp-meta-${Date.now()}-${path.basename(outputPath)}`);
+    try {
+        const { copiedEntries } = await copyNode.copyZipEntriesOnly(sourcePath, tempPath, {
+            entryFilter: (entry) => {
+                const name = entry.filename || entry.fileName || "";
+                return !replaceNames.has(name);
+            },
+        });
+        const destFd = fs.openSync(tempPath, "r+");
+        let offset = fs.fstatSync(destFd).size;
+        const allEntries = [...copiedEntries];
+        for (const entry of storedEntries) {
+            normalizeStoredMetadataEntry(entry);
+            entry.localHdrOffset = offset;
+            const localHeader = entry.createLocalHdr();
+            fs.writeSync(destFd, localHeader, 0, localHeader.length, offset);
+            offset += localHeader.length;
+            fs.writeSync(destFd, entry.fileBuffer, 0, entry.fileBuffer.length, offset);
+            offset += entry.fileBuffer.length;
+            entry.compressedSize = entry.fileBuffer.length;
+            allEntries.push(entry);
+        }
+        fs.closeSync(destFd);
+        copyNode.writeCentralDirectoryAndEOCD(tempPath, allEntries, {});
+        fs.renameSync(tempPath, outputPath);
+    }
+    catch (err) {
+        if (fs.existsSync(tempPath))
+            fs.unlinkSync(tempPath);
+        throw err;
+    }
+}
+async function loadArchiveMerkleRoot(archivePath) {
+    const zip = new ZipkitNode();
+    await zip.loadZipFile(archivePath);
+    const entries = zip.getDirectory() || [];
+    const merkleRoot = computeMerkleRoot(entries);
+    if (!merkleRoot) {
+        throw new Error("Archive has no SHA-256 hashes. Timestamped and tokenized archives require per-entry hashes.");
+    }
+    return merkleRoot;
+}
+function buildTimestampOptions(config, options) {
+    const timestampOptions = {};
+    const serverUrl = options.serverUrl || config.tokenServiceUrl || undefined;
+    const recipientEmail = options.recipientEmail || config.recipientEmail || undefined;
+    if (serverUrl)
+        timestampOptions.serverUrl = serverUrl;
+    if (recipientEmail)
+        timestampOptions.recipientEmail = recipientEmail;
+    if (config.debug)
+        timestampOptions.debug = true;
+    return timestampOptions;
+}
+async function submitArchiveTimestamp(merkleRoot, config, options, timestampOptions) {
+    const network = options.network || config.network;
+    const chainId = getChainIdByName(network) || undefined;
+    const serverUrl = timestampOptions.serverUrl || config.tokenServiceUrl || "";
+    const response = await submitDigest(merkleRoot, timestampOptions.recipientEmail, chainId, {
+        serverUrl,
+        debug: timestampOptions.debug,
+    });
+    if (!response.success) {
+        throw new Error(response.error || "Failed to create timestamp");
+    }
+    const resolvedChainId = response.chainId ||
+        (response.network ? getChainIdByName(response.network) : chainId) ||
+        0;
+    const contractConfig = resolvedChainId
+        ? getContractConfig(resolvedChainId)
+        : null;
+    const timestampMetadata = enrichTimestampMetadata({
+        digest: response.digest,
+        status: response.status === "confirmed"
+            ? "confirmed"
+            : "pending",
+        contractAddress: contractConfig?.address || "",
+        network: response.network || network,
+        chainId: resolvedChainId,
+        batchId: response.batchId ?? undefined,
+        batchNumber: response.batchNumber,
+        serverUrl,
+        submittedAt: new Date().toISOString(),
+    }, config.network, network);
+    return timestampMetadata;
+}
+export async function embedTimestampMetadata(archivePath, config, options = {}) {
+    const merkleRoot = await loadArchiveMerkleRoot(archivePath);
+    const timestampOptions = buildTimestampOptions(config, options);
+    if (!timestampOptions.recipientEmail) {
+        throw new Error("Recipient email required for timestamped archives. Run neozip-connect to verify your email, or pass options.recipientEmail.");
+    }
+    const timestampMetadata = await submitArchiveTimestamp(merkleRoot, config, options, timestampOptions);
+    if (!timestampMetadata) {
+        throw new Error("Token Service failed to create timestamp metadata.");
+    }
+    const zip = new ZipkitNode();
+    const metadataEntry = createTimestampMetadataEntry(zip, timestampMetadata);
+    if (!metadataEntry) {
+        throw new Error("Failed to build timestamp metadata entry.");
+    }
+    normalizeStoredMetadataEntry(metadataEntry);
+    await appendStoredEntries(archivePath, archivePath, [metadataEntry]);
+    return {
+        merkleRoot,
+        status: timestampMetadata.status ?? undefined,
+        batchId: timestampMetadata.batchId ?? undefined,
+    };
+}
+export async function embedTokenMetadata(archivePath, auth, config, options = {}) {
+    const walletKey = auth.requireWalletKey();
+    const network = options.network || config.network;
+    const merkleRoot = await loadArchiveMerkleRoot(archivePath);
+    const result = await mintArchiveToken(merkleRoot, {
+        walletPrivateKey: walletKey,
+        network,
+        debug: config.debug,
+    });
+    const mintResult = result.mintingResult;
+    if (!mintResult?.success) {
+        throw new Error(mintResult?.message || "NFT minting failed.");
+    }
+    if (!result.tokenMetadata) {
+        throw new Error("Mint succeeded but token metadata was not produced.");
+    }
+    const zip = new ZipkitNode();
+    const metadataEntry = createTokenMetadataZipEntry(zip, result.tokenMetadata);
+    if (!metadataEntry) {
+        throw new Error("Failed to build TOKEN.NZIP metadata entry.");
+    }
+    await appendStoredEntries(archivePath, archivePath, [metadataEntry]);
+    return {
+        merkleRoot,
+        tokenId: mintResult.tokenId,
+        transactionHash: mintResult.transactionHash,
+    };
+}
+async function readTimestampMetadata(zip, entry) {
+    const metadata = await extractTimestampData(zip, entry);
+    if (metadata)
+        return metadata;
+    try {
+        const tmpPath = path.join(os.tmpdir(), `neozip-mcp-upgrade-${Date.now()}.json`);
+        await zip.extractToFile(entry, tmpPath, { skipHashCheck: true });
+        try {
+            const buf = fs.readFileSync(tmpPath);
+            return JSON.parse(buf.toString("utf-8"));
+        }
+        finally {
+            if (fs.existsSync(tmpPath))
+                fs.unlinkSync(tmpPath);
+        }
+    }
+    catch {
+        return null;
+    }
+}
+function isTimestampConfirmed(confirmation) {
+    return Boolean(confirmation?.success &&
+        (confirmation.status === "confirmed" ||
+            (confirmation.verified && !!confirmation.transactionHash)));
+}
+/** Replace META-INF/TS-SUBMIT.NZIP with META-INF/TIMESTAMP.NZIP once the batch is on-chain. */
+export async function upgradeTimestampArchive(inputPath, outputPath, config, options = {}) {
+    const serviceOptions = {};
+    const serverUrl = options.serverUrl || config.tokenServiceUrl || undefined;
+    if (serverUrl)
+        serviceOptions.serverUrl = serverUrl;
+    if (config.debug)
+        serviceOptions.debug = true;
+    const zip = new ZipkitNode();
+    await zip.loadZipFile(inputPath);
+    const entries = zip.getDirectory() || [];
+    const metadataResult = findMetadataEntry(entries);
+    if (!metadataResult) {
+        throw new Error("No Token Service timestamp found in ZIP file.");
+    }
+    const metadata = await readTimestampMetadata(zip, metadataResult.entry);
+    if (!metadata) {
+        throw new Error("Failed to extract timestamp metadata.");
+    }
+    if (!shouldUpgrade(metadata, metadataResult.type)) {
+        throw new Error("Timestamp is already confirmed. No upgrade needed.");
+    }
+    const digest = metadata.digest;
+    if (!digest) {
+        throw new Error("Timestamp metadata is missing digest.");
+    }
+    const chainId = metadata.chainId;
+    const batchId = metadata.batchId || undefined;
+    const wait = options.wait !== false;
+    let confirmation;
+    if (wait) {
+        confirmation = await pollForConfirmation(digest, chainId, batchId, undefined, undefined, serviceOptions);
+    }
+    else {
+        confirmation = await verifyDigest(digest, chainId, batchId, undefined, serviceOptions);
+    }
+    if (!isTimestampConfirmed(confirmation) || !confirmation) {
+        throw new Error(confirmation?.error ||
+            "Timestamp batch not yet confirmed. Try again later or set options.wait: true.");
+    }
+    const confirmedMetadata = enrichTimestampMetadata({
+        ...metadata,
+        digest: confirmation.digest || metadata.digest,
+        status: "confirmed",
+        transactionHash: confirmation.transactionHash,
+        blockNumber: confirmation.blockNumber,
+        network: confirmation.network || metadata.network,
+        chainId: confirmation.chainId ?? metadata.chainId,
+        tokenId: confirmation.tokenId,
+        contractAddress: confirmation.contractAddress || metadata.contractAddress,
+        timestamp: confirmation.timestamp,
+        merkleRoot: confirmation.merkleRoot,
+        merkleProof: confirmation.merkleProof,
+        batchId: confirmation.batchId ?? metadata.batchId ?? undefined,
+        batchNumber: confirmation.batchNumber ?? metadata.batchNumber,
+        confirmedAt: new Date().toISOString(),
+    }, config.network);
+    const zipkit = new ZipkitNode();
+    const metadataEntry = createTimestampMetadataEntry(zipkit, confirmedMetadata);
+    if (!metadataEntry) {
+        throw new Error("Failed to build confirmed timestamp metadata entry.");
+    }
+    normalizeStoredMetadataEntry(metadataEntry);
+    await appendStoredEntries(inputPath, outputPath, [metadataEntry]);
+    const merkleRoot = await loadArchiveMerkleRoot(outputPath);
+    return {
+        inputPath,
+        outputPath,
+        merkleRoot,
+        transactionHash: confirmation.transactionHash,
+        network: confirmation.network,
+        blockNumber: confirmation.blockNumber,
+        tokenId: confirmation.tokenId,
+    };
+}
+//# sourceMappingURL=embed-metadata.js.map

package/dist/archive/encryption.js

@@ -0,0 +1,166 @@
+import { ZipkitNode } from "../neozipkit-node.js";
+import { extractEntryToBuffer } from "./extract-entry-buffer.js";
+/** Standard password for fixtures, smoke tests, and cursor scenarios (not for production). */
+export const FIXTURE_TEST_PASSWORD = "test-password";
+export const DEFAULT_PASSWORD_ENCRYPTION_METHOD = "neo-aes256";
+const STRENGTH_TO_METHOD = {
+    1: "zipcrypto",
+    2: "aes256",
+    3: "neo-aes256",
+};
+export function resolveEncryptionOptions(input) {
+    const password = input.password?.trim() || undefined;
+    const hasMethod = input.encryptionMethod != null;
+    const hasStrength = input.encryptionStrength != null;
+    if ((hasMethod || hasStrength) && !password) {
+        throw new Error("Password required when options.encryptionMethod or options.encryptionStrength is set.");
+    }
+    if (!password) {
+        return {};
+    }
+    let encryptionMethod = DEFAULT_PASSWORD_ENCRYPTION_METHOD;
+    if (hasMethod) {
+        encryptionMethod = input.encryptionMethod;
+    }
+    else if (hasStrength) {
+        encryptionMethod = STRENGTH_TO_METHOD[input.encryptionStrength];
+    }
+    return { password, encryptionMethod };
+}
+/** neozipkit decrypt: set password on the ZipkitNode instance after load. */
+export function applyArchivePassword(zip, password) {
+    const key = password?.trim();
+    if (!key)
+        return;
+    zip.password = key;
+}
+export function isEntryEncrypted(entry) {
+    return Boolean(entry.encrypted ?? entry.isEncrypted);
+}
+export function getEntryEncryptionLabel(entry) {
+    if (!isEntryEncrypted(entry))
+        return undefined;
+    if ((entry.neoCryptoAlgorithm ?? 0) > 0) {
+        return "NeoZip AES";
+    }
+    const aesVersion = entry.aesVersion ?? 0;
+    if (aesVersion === 1)
+        return "AES-128";
+    if (aesVersion === 2)
+        return "AES-192";
+    if (aesVersion >= 3)
+        return "AES-256";
+    return "ZipCrypto";
+}
+export function encryptionMethodDisplayName(method) {
+    switch (method) {
+        case "zipcrypto":
+            return "PKZIP (ZipCrypto)";
+        case "aes256":
+            return "WinZip AES-256";
+        case "neo-aes256":
+            return "NeoZip AES-256";
+    }
+}
+function payloadEncryptedEntries(entries, skipEntry) {
+    return entries.filter((entry) => {
+        if (entry.isDirectory)
+            return false;
+        const name = entry.fileName || entry.filename || "";
+        if (skipEntry?.(name))
+            return false;
+        return isEntryEncrypted(entry);
+    });
+}
+/**
+ * Decrypt encrypted payload entries with the given password and confirm a wrong
+ * password does not yield the same plaintext.
+ */
+export async function verifyEncryptedArchivePassword(archivePath, zipWithPassword, entries, password, skipEntry) {
+    const encrypted = payloadEncryptedEntries(entries, skipEntry);
+    const failed = [];
+    let verified = 0;
+    let wrongPasswordRejected = true;
+    if (encrypted.length === 0) {
+        return {
+            encryptedEntryCount: 0,
+            verified: 0,
+            failed: [],
+            wrongPasswordRejected: true,
+        };
+    }
+    const goodBuffers = new Map();
+    for (const entry of encrypted) {
+        const name = entry.fileName || entry.filename || "";
+        try {
+            const buf = await extractEntryToBuffer(zipWithPassword, entry);
+            if (buf.length === 0) {
+                failed.push(`${name}: decrypt produced empty data`);
+                continue;
+            }
+            goodBuffers.set(name, buf);
+            verified++;
+        }
+        catch (err) {
+            failed.push(`${name}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    const sample = encrypted[0];
+    const sampleName = sample.fileName || sample.filename || "";
+    const zipNoPassword = new ZipkitNode();
+    await zipNoPassword.loadZipFile(archivePath);
+    try {
+        const withoutPwd = await extractEntryToBuffer(zipNoPassword, sample);
+        const good = goodBuffers.get(sampleName);
+        if (good && withoutPwd.length > 0 && withoutPwd.equals(good)) {
+            wrongPasswordRejected = false;
+            failed.push(`${sampleName}: decrypt without password matched password-protected plaintext`);
+        }
+    }
+    catch {
+        // Expected when decryption requires a password
+    }
+    const zipWrongPassword = new ZipkitNode();
+    await zipWrongPassword.loadZipFile(archivePath);
+    applyArchivePassword(zipWrongPassword, `${password}-invalid`);
+    try {
+        const wrongPwd = await extractEntryToBuffer(zipWrongPassword, sample);
+        const good = goodBuffers.get(sampleName);
+        if (good && wrongPwd.length > 0 && wrongPwd.equals(good)) {
+            wrongPasswordRejected = false;
+            failed.push(`${sampleName}: wrong password produced same plaintext as correct password`);
+        }
+    }
+    catch {
+        // Expected for wrong password
+    }
+    return {
+        encryptedEntryCount: encrypted.length,
+        verified,
+        failed,
+        wrongPasswordRejected,
+    };
+}
+export function formatPasswordDecryptVerification(result) {
+    const lines = [];
+    if (result.encryptedEntryCount === 0) {
+        lines.push("Password verification: skipped (no encrypted payload entries)");
+        return lines;
+    }
+    lines.push(`Password verification: ${result.verified}/${result.encryptedEntryCount} entries decrypted`);
+    if (result.wrongPasswordRejected) {
+        lines.push("Wrong-password check: PASSED");
+    }
+    else {
+        lines.push("Wrong-password check: FAILED");
+    }
+    for (const msg of result.failed) {
+        lines.push(`  FAIL: ${msg}`);
+    }
+    const passed = result.failed.length === 0 &&
+        result.verified === result.encryptedEntryCount &&
+        result.wrongPasswordRejected;
+    lines.push(`Password decrypt verification: ${passed ? "PASSED" : "FAILED"}`);
+    return lines;
+}
+//# sourceMappingURL=encryption.js.map

package/dist/archive/extract-entry-buffer.js

@@ -0,0 +1,18 @@
+export async function extractEntryToBuffer(zip, entry) {
+    if (entry.cmpMethod === 0 &&
+        (entry.realCmpMethod == null || entry.realCmpMethod < 0)) {
+        entry.realCmpMethod = 0;
+    }
+    if (typeof zip.extractToBuffer === "function") {
+        const buffer = await zip.extractToBuffer(entry);
+        if (buffer && Buffer.isBuffer(buffer)) {
+            return buffer;
+        }
+    }
+    const buffer = await zip.extract(entry);
+    if (!buffer || !Buffer.isBuffer(buffer)) {
+        throw new Error("Failed to extract entry");
+    }
+    return buffer;
+}
+//# sourceMappingURL=extract-entry-buffer.js.map

package/dist/archive/find-entry.js

@@ -0,0 +1,21 @@
+export function normalizeEntryPath(entryPath) {
+    const normalized = entryPath.replace(/\\/g, "/").replace(/^\/+/, "");
+    const segments = normalized.split("/").filter((s) => s.length > 0);
+    for (const segment of segments) {
+        if (segment === "..") {
+            throw new Error("Entry path must not contain '..' segments.");
+        }
+    }
+    return segments.join("/");
+}
+export function findEntryByPath(entries, entryPath) {
+    const normalized = normalizeEntryPath(entryPath);
+    const exact = entries.find((e) => (e.fileName || e.filename) === normalized);
+    if (exact)
+        return exact;
+    const withSlash = entries.find((e) => (e.fileName || e.filename) === `${normalized}/`);
+    if (withSlash)
+        return withSlash;
+    throw new Error(`Entry not found: ${normalized}`);
+}
+//# sourceMappingURL=find-entry.js.map

package/dist/archive/grep-content.js

@@ -0,0 +1,141 @@
+import { minimatch } from "minimatch";
+import { buildEntrySummary } from "./manifest.js";
+import { isBufferTextSafe } from "./detect-text.js";
+import { extractEntryToBuffer } from "./extract-entry-buffer.js";
+function truncateSnippet(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    return text.slice(0, maxChars) + "…";
+}
+function lineMatches(line, pattern, mode, caseSensitive) {
+    if (mode === "regex") {
+        const flags = caseSensitive ? "g" : "gi";
+        const regex = new RegExp(pattern, flags);
+        const match = regex.exec(line);
+        if (!match)
+            return { matched: false, column: 0 };
+        return { matched: true, column: (match.index ?? 0) + 1 };
+    }
+    const haystack = caseSensitive ? line : line.toLowerCase();
+    const needle = caseSensitive ? pattern : pattern.toLowerCase();
+    const index = haystack.indexOf(needle);
+    if (index === -1)
+        return { matched: false, column: 0 };
+    return { matched: true, column: index + 1 };
+}
+export function grepTextLines(text, pattern, options) {
+    if (options.mode === "regex") {
+        try {
+            new RegExp(pattern, options.caseSensitive ? "g" : "gi");
+        }
+        catch {
+            throw new Error("Invalid regex pattern.");
+        }
+    }
+    const lines = text.split(/\r?\n/);
+    const results = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const { matched, column } = lineMatches(line, pattern, options.mode, options.caseSensitive);
+        if (!matched)
+            continue;
+        const match = {
+            line: i + 1,
+            column,
+            snippet: truncateSnippet(line, options.maxSnippetChars),
+        };
+        if (options.contextLines > 0) {
+            const start = Math.max(0, i - options.contextLines);
+            const end = Math.min(lines.length - 1, i + options.contextLines);
+            match.contextBefore = lines.slice(start, i);
+            match.contextAfter = lines.slice(i + 1, end + 1);
+        }
+        results.push(match);
+    }
+    return results;
+}
+function entryMatchesPathFilter(entryPath, pathFilter, caseSensitive) {
+    if (!pathFilter)
+        return true;
+    const normalizedPath = entryPath.replace(/\\/g, "/");
+    const normalizedFilter = pathFilter.replace(/\\/g, "/");
+    if (normalizedFilter.includes("*") || normalizedFilter.includes("?")) {
+        return minimatch(normalizedPath, normalizedFilter, {
+            nocase: !caseSensitive,
+            dot: true,
+        });
+    }
+    if (normalizedPath === normalizedFilter)
+        return true;
+    if (normalizedPath.startsWith(`${normalizedFilter}/`))
+        return true;
+    return normalizedPath.startsWith(normalizedFilter);
+}
+export async function grepArchiveEntries(archivePath, zip, entries, options) {
+    const matches = [];
+    let filesScanned = 0;
+    let filesSkipped = 0;
+    let truncated = false;
+    for (const entry of entries) {
+        if (matches.length >= options.maxMatches) {
+            truncated = true;
+            break;
+        }
+        const entryPath = entry.fileName || entry.filename || "";
+        if (entry.isDirectory) {
+            filesSkipped++;
+            continue;
+        }
+        if (!entryMatchesPathFilter(entryPath, options.pathFilter, options.caseSensitive)) {
+            filesSkipped++;
+            continue;
+        }
+        const summary = buildEntrySummary(entry);
+        if (!summary.isTextSafe) {
+            filesSkipped++;
+            continue;
+        }
+        const uncompressedSize = entry.uncompressedSize || 0;
+        if (uncompressedSize > options.maxFileBytes) {
+            filesSkipped++;
+            continue;
+        }
+        const buffer = await extractEntryToBuffer(zip, entry);
+        if (!buffer || !Buffer.isBuffer(buffer)) {
+            filesSkipped++;
+            continue;
+        }
+        if (!isBufferTextSafe(buffer)) {
+            filesSkipped++;
+            continue;
+        }
+        filesScanned++;
+        const text = buffer.toString("utf-8");
+        const lineMatches = grepTextLines(text, options.pattern, options);
+        for (const lm of lineMatches) {
+            if (matches.length >= options.maxMatches) {
+                truncated = true;
+                break;
+            }
+            matches.push({
+                path: entryPath,
+                line: lm.line,
+                column: lm.column,
+                snippet: lm.snippet,
+                ...(lm.contextBefore?.length ? { contextBefore: lm.contextBefore } : {}),
+                ...(lm.contextAfter?.length ? { contextAfter: lm.contextAfter } : {}),
+            });
+        }
+    }
+    return {
+        archive: archivePath,
+        pattern: options.pattern,
+        mode: options.mode,
+        filesScanned,
+        filesSkipped,
+        matchCount: matches.length,
+        truncated,
+        matches,
+    };
+}
+//# sourceMappingURL=grep-content.js.map