Skip to content
verify mcp Beta VerifyMCP is currently in beta. If you notice any issues, get in touch and we’ll put it right.

zipnative MCP — ZIP creation, inspection, secure extraction & verification

NPM · ZIPNATIVE-MCP

ZIP MCP server: create, inspect, verify, extract, canonicalize, merge, modify. 15 tools

Available components

0 this week 95 Trust /100

Last scanned (6 hours ago)

Scores higher than 97% of npm servers

Category Documents and Files

Trust breakdown (7 categories)

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. How we score → Why this is hard to score →

Supply Chain Security100
  • No malware found by supply-chain analysis.Pass
  • No known CVEs affecting this package version or its production dependencies.Pass
  • No install/post-install scripts declared.Pass
  • 0 of 4 dependencies flagged as unhealthy. View diagnostics → Pass
Provenance & Transparency100
  • Source repository is publicly reachable at the declared URL. View diagnostics → Pass
  • Cryptographically verified build provenance (signed, bound to Nizoka/zipnative-mcp). View diagnostics → Pass
  • Clear OSI-approved license (MIT).Pass
  • Actively maintained (last published 33 days ago).Pass
  • Publishes a security disclosure policy (SECURITY.md).Pass
Schema Quality & AI Usability72
  • 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).Pass
  • AI-judged instruction clarity (excellent).Pass
  • Context-footprint check failed: tool/resource definitions use about 10460 tokens (~697/item across 15 items; 15 tools + 0 resources), over budget; trim descriptions and params. See how to fix → Fail
  • Usage-examples check failed: none of the tools include examples. See how to fix → Fail
Stability & Change Management100
  • No destabilizing schema changes in the last 30 days.Pass
Tool Coverage100
  • 100% of tools have a non-trivial description (not blank, and not just the tool's name).Pass
  • 100% of tool parameters carry a description.Pass
  • Structured output schemas are declared (100% of tools); any adoption earns full credit.Pass
Tool Safety100
  • No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.Pass
  • All 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.Pass
  • An AI judge read all 16 captured unit(s) of tool text and found none that tries to manipulate the model reading it.Pass
Capabilities100
  • Implements a current MCP spec version (2026-07-28).Pass
What we tested

Checks we ran (16)

  • Malware scan
  • Known CVEs
  • Install scripts
  • Dependency health
  • Source repository
  • Provenance
  • License
  • Maintenance
  • Security disclosure
  • Schema quality
  • Stability
  • Tool coverage
  • Injection markers
  • Destructive annotations
  • Judged manipulation
  • MCP protocol

Does not apply to this package (2)

  • Endpoint SecurityScored on hosted endpoints only. A package has no live endpoint of its own for us to probe.
  • Transport & ReachabilityScored on hosted endpoints only. A package has no live endpoint of its own for us to probe.

The score does not measure everything. What the score does not measure →

Changelog

Every change we have recorded for this component, newest first. Security-relevant changes are always shown. ▲ marks a change for the better, ▼ a change for the worse; unmarked changes are neutral.

  • 14 Nov 26 0
    • Stability: 0.97 → pass security
  • 13 Nov 26 0
    • Stability: pass → 0.97 functional
  • 9 Nov 26 +5
    • Source repository: unverified → pass ▲ security
  • 8 Nov 26 −5
    • Provenance: pass → unverified ▼ security
  • 7 Nov 26 0
    • Stability: 0.97 → pass security
  • 6 Nov 26 +1

    No change was recorded against any check on this day. Stability & Change Management went from 93 to 97. That category is still filling its 30-day observation window: 28 days of observed history at the previous scan, 29 at this one. The score rises as the window fills, whether or not the server changes.

  • 4 Nov 26 −1
    • Stability: pass → 0.90 functional
  • 29 Oct 26 0
    • Stability: 0.97 → pass security
Diagnostics

Diagnostic detail from the automated scan of this channel: what the scanner observed at each step, so you can see exactly where a check passed or failed. It is informational only and never changes the trust score.

Captured 22 Nov 2026 · Analysed npm/zipnative-mcp@1.1.0

Provenance Verified

A signed build attestation was found and verified, binding this exact artifact to the source repository it claims to come from.

Result Verified
Ecosystem npm
Reason Verified
Discovered via Registry attestation endpoint
Source repo Nizoka/zipnative-mcp
Certificate issuer https://token.actions.githubusercontent.com
Certificate SAN https://github.com/Nizoka/zipnative-mcp/.github/workflows/publish.yml@refs/tags/v1.1.0
Rekor log index 3320648862
Predicate type SLSA build provenance https://slsa.dev/provenance/v1
Subject digest sha512:491e72f911ec53c3adf87d668e93ee42cfd41454fb661f9a3f425f02294f810527ea07a2033e384dcd8cd614a35708662240e14c396794e1b52d9c6b4

Background: How many MCP packages publish verified provenance →

Dependencies 4 packages
Packages resolved 4
Tree resolution Complete

Background: SBOMs and build attestations, explained →

MCP tools · 15 exposed · ~9,107 tokens

The tools this component advertises to a client, with an estimated token cost for each. Expand a tool to see its parameters and schema. The per-tool counts are indicative and are not scored directly; the schema's total context footprint is one signal in Schema Quality & AI Usability. A tool's description is untrusted text the model reads on every call, which is what makes this list a security surface and not just an inventory: how tool poisoning works →

Tool Tokens
canonicalize_zip ~677

Make ANY archive reproducible: zipnative's canonicalizeZip() rewrites a Gradle, Maven, zip, Explorer or 7-Zip archive into the canonical deterministic form zipnative itself writes — entries sorted by raw name bytes, one timestamp (the DOS epoch, or a pinned `date`, read as UTC), the UTF-8 flag on every name, no extra field but Zip64, the constant version-made-by, no data descriptor — WITHOUT recompressing a payload (the compressed bytes travel bit for bit; nothing is decoded, so the result is identical on every runtime). Idempotent: canonicalising the result again returns the same bytes (summary.alreadyCanonical). Entry names and payloads travel verbatim (a corrupt or unsafe entry stays so — run verify_zip first when integrity matters). summary.canonicalForm is the engine's own analyzeDeterminism() verdict on the output. keepComments (default false) and keepExternalAttributes (default true) choose what survives. Duplicate-name archives are refused. Verify with inspect_zip { check:['canonical-form'], canonicalDate } and compare summary.sha256 across builds.

NameTypeReqDescription
datestring–The one timestamp written on every entry (ISO-8601, 1980-01-01 … 2107-12-31, read as UTC; 2-second DOS granularity). Default: the DOS epoch 1980-01-01T00:00:00 — the deterministic default. Pass the s…
includeSha256boolean–Add `summary.sha256` of the produced bytes (the reproducibility proof to compare across builds).
keepCommentsboolean–Keep the archive comment and the entry comments (default false: the canonical form carries none).
keepExternalAttributesboolean–Keep each entry's external attributes — Unix modes, DOS attributes (default true); false writes the canonical defaults (0o100644 files, 0o40755 directories).
limitsobject–Per-call override of zipnative's security bounds (CWE-400/409); absent keys keep the engine defaults (describe_engine.defaultLimits). A value above its operator ceiling is LIMIT_CEILING_EXCEEDED. Rai…
outputModestring–'base64' (default): inline embedded resource (≤ 50 MiB; the bytes appear in both its data: uri and its blob). 'file': written into the sandbox (never overwrites; ≤ ZIPNATIVE_MCP_MAX_FILE_OUTPUT_BYTES…
outputPathstring–Relative path inside the sandbox (only when outputMode='file'); must end in a container extension (.zip recommended).
strictboolean–Turn the first engine diagnostic into a ZIP_STRICT_DIAGNOSTIC error.
zipBase64string–Archive bytes, base64 (≤ 128 MiB decoded). Exclusive with zipPath.
zipPathstring–Archive path relative to the ZIPNATIVE_MCP_OUTPUT_DIR sandbox (container extensions: .zip .jar .docx .epub …). Exclusive with zipBase64; saves re-sending bytes between calls.
NameTypeReqDescription
diagnosticCountsobject–Occurrences per code, duplicates included.
diagnosticsarrayyesNon-fatal engine concerns (de-duplicated by code + entry, ≤ 200; codes in describe_engine.diagnosticCodes). Empty for a clean archive.
diagnosticsTruncatedboolean–true when rows beyond 200 were dropped.
filePathstring–Sandboxed absolute path (file mode).
modestringyes–
sizeBytesintegeryes–
summaryobjectyescanonicalize_zip summary.

No examples provided.

compute_crc32 ~222

The ZIP checksum (IEEE 802.3 CRC-32, the engine's slice-by-8 implementation) of inline bytes / text or a sandbox file (streamed in 1 MiB chunks). `seed` continues a running CRC across consecutive chunks; `expect` compares against a known value (`matches`). Use it to cross-check an entry's crc32 from list_zip_entries against a file on disk.

NameTypeReqDescription
dataBase64string–Bytes as base64. Exclusive with text / sourcePath.
expectstring–Optional expected CRC (1–8 hex digits, optional 0x prefix, e.g. '4e08bfb4'); the result carries `matches`.
seedinteger–Running CRC to continue from (chain calls over consecutive chunks).
sourcePathstring–Relative path of a file inside the sandbox (streamed, ≤ 1 GiB). Exclusive with dataBase64 / text.
textstring–UTF-8 text. Exclusive with dataBase64 / sourcePath.
NameTypeReqDescription
byteLengthintegeryes–
crc32integeryesUnsigned 32-bit CRC.
hexstringyes8 lowercase hex digits.
matchesboolean–Present when `expect` was given.
seedintegeryes–

No examples provided.

create_zip ~865

Write a ZIP from inline entries (`dataBase64` | `text` | `sourcePath` in the sandbox, or `directory:true`). Reproducible by default: canonical order (raw UTF-8 name bytes), DOS-epoch timestamps, UTF-8 names, constant attributes — `defaultDate:'now'` or per-entry `date` opts out (ZIP_TIMESTAMP_NOT_PINNED diagnostic). `compression` {method store|deflate, level 0–9, deterministic:true = pinned pure-TS encoder ⇒ identical bytes on every runtime} at archive or entry level; `order:'insertion'` for EPUB / JAR (mimetype first, stored); `comment`, per-entry comment / unixMode / externalAttributes / raw extraFields. `stream:true` on a sourcePath feeds the file through addStream (data-descriptor layout, bounded memory). `parallel` compresses with the worker pool — byte-identical output. Zip64 is emitted exactly when a field overflows. Output base64 (≤ 50 MiB) or a sandbox file (streamed, never overwritten); `summary.deterministic` is true ONLY with compression.deterministic:true (cross-runtime identity); a default call is reproducible on the same runtime (`deflateTier` 'node-zlib') and reports false; `sha256` (includeSha256, base64 and file modes) is the proof. Every archive it writes is ISO/IEC 21320-1 conformant (CI-validated).

NameTypeReqDescription
chunkSizeinteger–file mode: output chunk size for the streaming assembler (default 64 KiB). Never changes the bytes.
commentstring–Archive comment (UTF-8, ≤ 65535 bytes).
compressionobject–Compression settings. `method` 'deflate' (default) or 'store'; `level` 0–9 (default 6); `deterministic: true` pins the pure-TS encoder so the bytes are identical on every runtime (slower).
defaultDatestring–Timestamp for entries that set no `date`: an ISO-8601 instant (1980-01-01 … 2107-12-31, 2-second DOS granularity) or 'now' (wall clock — emits the ZIP_TIMESTAMP_NOT_PINNED diagnostic and makes the by…
entriesarrayyesThe entries to write (0–100000; an empty array writes a valid empty archive). Each takes exactly one of dataBase64 / text / sourcePath, or directory: true.
includeSha256boolean–Add `summary.sha256` of the produced bytes (determinism proofs).
limitsobject–Per-call override of zipnative's security bounds (CWE-400/409); absent keys keep the engine defaults (describe_engine.defaultLimits). A value above its operator ceiling is LIMIT_CEILING_EXCEEDED. Rai…
orderstring–'canonical' (default): entries sorted by raw UTF-8 name bytes (reproducible). 'insertion': call order preserved (EPUB / JAR mimetype-first layouts).
outputModestring–'base64' (default): inline embedded resource (≤ 50 MiB; the bytes appear in both its data: uri and its blob). 'file': written into the sandbox (never overwrites; ≤ ZIPNATIVE_MCP_MAX_FILE_OUTPUT_BYTES…
outputPathstring–Relative path inside the sandbox (only when outputMode='file'); must end in a container extension (.zip recommended).
parallelobject–Compress with the worker pool (zipnative/worker). Byte-identical to the sequential writer; only worth it for many large entries. `workers` 0 keeps everything on the calling thread.
strictboolean–Turn the first engine diagnostic into a ZIP_STRICT_DIAGNOSTIC error.
NameTypeReqDescription
diagnosticCountsobject–Occurrences per code, duplicates included.
diagnosticsarrayyesNon-fatal engine concerns (de-duplicated by code + entry, ≤ 200; codes in describe_engine.diagnosticCodes). Empty for a clean archive.
diagnosticsTruncatedboolean–true when rows beyond 200 were dropped.
filePathstring–Sandboxed absolute path (file mode).
modestringyes–
sizeBytesintegeryes–
summaryobjectyescreate_zip summary.

No examples provided.

describe_engine ~232

Offline preflight (no archive needed): server / engine / tool-API versions, the deflate tier in use and the pinned deterministic tier, runtime codecs (node:zlib, CompressionStream, DecompressionStream) and worker threads, the codec registry, the engine's default `limits`, the four operator ceilings (ZIPNATIVE_MCP_MAX_UNCOMPRESSED_BYTES, ZIPNATIVE_MCP_MAX_ENTRIES, ZIPNATIVE_MCP_WORKERS, ZIPNATIVE_MCP_MAX_FILE_OUTPUT_BYTES), every server cap, whether the sandbox and the cache are enabled, the 39 frozen ZIP_* error codes and 12 diagnostic codes, and the engine exports this server deliberately does not expose (with why). `network` is always 'none'. Call it first in a session, or whenever a cap / ceiling refusal needs interpreting.

NameTypeReqDescription
fieldsarray–Dot-paths to keep, after verbosity (e.g. ['entryCount', 'entries.name']); unmatched ones are listed in _meta.unmatchedFields.
verbositystring–'summary': scalar verdict fields only (the token-frugal form).
NameTypeReqDescription
capabilitiesobject––
capsobject––
ceilingsobject––
codecsarray––
defaultLimitsobject––
diagnosticCodesarray––
engineobject––
errorCodesarray––
networkstring––
sandboxobject––
serverobject––
unexposedarray––

No examples provided.

draft_governance_issue ~513

Produce a LOCAL GitHub issue draft + compliance report for zipnative / zipnative-mcp and NEVER submit it — the agent drafts, a human reviews and files it under their own identity (Human-In-The-Loop contract, .github/AGENT_RULES.md). No GitHub write path and no network path exist in this server. The draft is checked against the zero-dependency + reproduction policy; a policy violation (a new runtime dependency, duplicateSearchPerformed:false) is GOVERNANCE_VIOLATION; a missing field (reproduction included) is VALIDATION_ERROR. targetRepo 'zipnative' for engine behaviour (parsing, writing, limits, codecs), 'zipnative-mcp' for wrapper behaviour (schemas, sandbox, transport). Returns markdown inline (outputMode:'file' also writes a .md inside the sandbox). Use it only after reproducing a defect — for questions read describe_engine / docs/AGENT_CONTRACT.md instead. Present the draft AND the report to the user, then STOP.

NameTypeReqDescription
actualBehaviorstring–What actually happened (defaults to the reproduction result when omitted).
affectedPackagesarray–Packages impacted by this issue (e.g. ["zipnative-mcp"], ["zipnative"]).
duplicateSearchPerformedbooleanyesMUST be true: confirms you searched open AND closed issues/PRs for duplicates before drafting.
expectedBehaviorstringyesWhat you expected to happen instead.
issueTypestringyesIssue category: 'bug' | 'feature' | 'security' | 'docs' | 'performance'.
outputModestring–'inline' (default) returns the draft markdown in the response. 'file' additionally writes it to the sandbox (requires ZIPNATIVE_MCP_OUTPUT_DIR); outputPath must be a relative .md path.
outputPathstring–Relative .md path inside the sandbox (only when outputMode='file').
reproductionobjectyesThe minimal, locally-executed reproduction that justifies this issue.
summarystringyesOne or two paragraphs describing the problem or proposal.
targetRepostring–Destination repository label for the draft (documentation only — the server never contacts it). 'zipnative-mcp' (wrapper: schemas, sandbox, transport) or 'zipnative' (engine: parser, writer, limits,…
titlestringyesConcise issue title (imperative, no trailing period).
NameTypeReqDescription
complianceobjectyes–
draftMarkdownstringyesThe full draft, ready for a human to review and submit.
filePathstring–Sandboxed absolute path (when outputMode='file').
issueTypestringyes–
outputModestringyes–
sizeBytesintegeryes–
targetRepostringyes–
titlestringyes–
warningsarrayyes–

No examples provided.

extract_zip ~851

Extract with every engine guard ON unless you name the relaxation: zip-slip / absolute / drive / UNC / NUL / ADS / Windows-device names → ZIP_PATH_TRAVERSAL (rejectTraversal:false SKIPS them, listed in `skipped`; an unsafe path is never emitted); symlinks → ZIP_SYMLINK_REJECTED (rejectSymlinks:false extracts the target text as data, never a link); duplicate sanitized paths → ZIP_EXTRACT_DUPLICATE_PATH (onDuplicate 'first' | 'last'); declared sizes / ratios beyond `limits` → ZIP_LIMIT_EXCEEDED; overlapping entries and central/local divergence are always refused. `filter` keeps a subset. outputMode 'base64' (default) returns files inline (≤ 16 MiB each, ≤ 32 MiB total; includeData:false = dry run of the plan); 'file' streams into a relative `outputDir` inside ZIPNATIVE_MCP_OUTPUT_DIR (never overwrites) and returns resource links. Directories are implied by paths (emptyDirectories:true creates the explicit ones). The dry run opens eagerly: an overlapping, offset-into-CD or Zip64-spoofed archive is refused before any plan is returned. Prefer read_zip_entry for a single file.

NameTypeReqDescription
emptyDirectoriesboolean–file mode: also create explicit directory entries (with a safe name) that hold no file.
fieldsarray–Dot-paths to keep, after verbosity (e.g. ['entryCount', 'entries.name']); unmatched ones are listed in _meta.unmatchedFields.
filterobject–Select entries: `names` (exact), `prefix`, `glob` (`*` in a segment, `**` across, `?`, `[a-z]`; no `/` = any depth, trailing `/` = subtree), ANDed; `includeDirectories` (default false).
includeDataboolean–base64 mode: false = dry run — list what WOULD be extracted (paths, sizes) without decompressing or returning bytes.
limitsobject–Per-call override of zipnative's security bounds (CWE-400/409); absent keys keep the engine defaults (describe_engine.defaultLimits). A value above its operator ceiling is LIMIT_CEILING_EXCEEDED. Rai…
onDuplicatestring–Two entries mapping to the same sanitized path: 'error' (default, ZIP_EXTRACT_DUPLICATE_PATH), keep the 'first', or keep the 'last'.
outputDirstring–Relative directory inside the sandbox to extract into (file mode; created if absent; no absolute paths, no '..').
outputModestring–'base64' (default): files inline (≤ 16777216 bytes each, ≤ 33554432 bytes total). 'file': stream every file under outputDir inside ZIPNATIVE_MCP_OUTPUT_DIR (never overwrites) and return resource link…
rejectSymlinksboolean–true (default): a symlink entry fails the call with ZIP_SYMLINK_REJECTED. false: its target text is extracted as ordinary data (never materialised as a link).
rejectTraversalboolean–true (default): an entry whose name escapes the root (zip-slip, absolute, drive/UNC, NUL, ADS, Windows device name) fails the call with ZIP_PATH_TRAVERSAL. false: such entries are SKIPPED and listed…
strictboolean–Turn the first engine diagnostic into a ZIP_STRICT_DIAGNOSTIC error.
verbositystring–'summary': scalar verdict fields only (the token-frugal form).
zipBase64string–Archive bytes, base64 (≤ 128 MiB decoded). Exclusive with zipPath.
zipPathstring–Archive path relative to the ZIPNATIVE_MCP_OUTPUT_DIR sandbox (container extensions: .zip .jar .docx .epub …). Exclusive with zipBase64; saves re-sending bytes between calls.
NameTypeReqDescription
diagnosticCountinteger–summary only: number of distinct diagnostics.
diagnosticCountsobject–Occurrences per code, duplicates included.
diagnosticsarray–Non-fatal engine concerns (de-duplicated by code + entry, ≤ 200; codes in describe_engine.diagnosticCodes). Empty for a clean archive.
diagnosticsTruncatedboolean–true when rows beyond 200 were dropped.
directoriesCreatedinteger––
dryRunboolean–true when includeData was false: nothing was decompressed.
entriesarray–One row per extracted file, in central-directory order. base64 mode carries dataBase64 (unless dryRun); file mode carries filePath.
fileCountinteger––
modestring––
outputDirstring–Absolute sandbox directory (file mode).
pathsarray–summary only: the extracted paths.
skippedarray–Entries skipped because their name is unsafe (only with rejectTraversal:false).
skippedCountinteger–summary only: number of skipped (unsafe-path) entries.
totalBytesinteger–Sum of the extracted (or planned) uncompressed sizes.

No examples provided.

inflate_raw ~500

Decompress a raw DEFLATE (RFC 1951) stream — e.g. the payload from read_zip_entry mode:'raw' — with a MANDATORY `maxOutput` bound through zipnative's resumable inflater (constant memory, exact `bytesConsumed`, trailing bytes reported as `leftover`; ZIP_INFLATE_OUTPUT_OVERFLOW past the bound). method 'store' is a bounded pass-through; a numeric method id selects a registered codec (none beyond 0 / 8 in this server → ZIP_UNSUPPORTED_METHOD). Output base64 (≤ 50 MiB) or a sandbox file. Use it only for a raw payload or a bare deflate stream; to read an entry's content prefer read_zip_entry mode:'data'.

NameTypeReqDescription
allowTrailingboolean–Accept bytes after the end of the deflate stream silently (they are always reported as `leftover`).
dataBase64string–The compressed stream as base64 (e.g. the payload from read_zip_entry mode:"raw"). Exclusive with sourcePath.
maxOutputintegeryesMandatory output bound in bytes: decompression stops with ZIP_INFLATE_OUTPUT_OVERFLOW beyond it (zip-bomb guard). Inline results are further capped at 52428800 bytes, file results at the file cap (ZI…
methodstring–'deflate' (default, method 8), 'store' (method 0, bounded pass-through) or a numeric method id for a registered codec.
outputModestring–'base64' (default): inline embedded resource (≤ 50 MiB; the bytes appear in both its data: uri and its blob). 'file': written into the sandbox (never overwrites; ≤ ZIPNATIVE_MCP_MAX_FILE_OUTPUT_BYTES…
outputPathstring–Relative path inside the sandbox (only when outputMode='file'); the inflated bytes are raw data, so it must end in .bin, .dat, .raw, .txt, .json, .xml, .md, .csv, .html, .tar or .zip.
sourcePathstring–Relative path of a file inside the sandbox holding the compressed stream (streamed). Exclusive with dataBase64.
NameTypeReqDescription
diagnosticCountsobject–Occurrences per code, duplicates included.
diagnosticsarrayyesNon-fatal engine concerns (de-duplicated by code + entry, ≤ 200; codes in describe_engine.diagnosticCodes). Empty for a clean archive.
diagnosticsTruncatedboolean–true when rows beyond 200 were dropped.
filePathstring–Sandboxed absolute path (file mode).
modestringyes–
sizeBytesintegeryes–
summaryobjectyesinflate_raw summary (the produced bytes are application/octet-stream, not an archive).

No examples provided.

inspect_zip ~835

Read-only archive report in ONE call: size, entry / file / directory counts, Zip64, comment, compressed vs uncompressed totals, per-method counts, encrypted / symlink / data-descriptor / Zip64 / cp437 / duplicate / unsafe-name counts, date range, a `determinism` verdict (epoch timestamps + canonical order + UTF-8 flags ⇒ reproducible; `canonicalLayout` = no data descriptors) and every engine diagnostic (prepended SFX data, name mismatches, …). Opens EAGERLY by default: every entry's real extent is checked up front — overlapping entries, entries reaching into the central directory or past EOF, and Zip64 spoofing — and refused with their ZIP_* code rather than summarised (a method / CRC / size divergence between central and local headers is caught by verify_zip and on read, not here). `check:[…]` / `assert:{…}` turn it into a CI gate → `checks[]` + `checksPassed`. Token-frugal: verbosity:'summary', fields:[…]. Input: zipBase64 or zipPath (sandbox).

NameTypeReqDescription
accessstring–'auto' (default): in memory, and a zipPath above 1073741824 bytes by byte ranges. 'range': always by byte ranges over the sandbox file (never a URL; memory ≈ the central directory). 'memory': always…
assertobject–Parametrised assertions (each becomes a `checks[]` row).
canonicalDatestring–The date the archive was canonicalised with (canonicalize_zip `date`, modify_zip `canonical.date`): the canonical-form verdict then expects that timestamp on every entry instead of the DOS epoch. Rea…
checkarray–CI assertions evaluated over the report: deterministic, epoch-timestamps, canonical-order, utf8-names, no-data-descriptor, canonical-layout, no-zip64, zip64, no-encryption, no-symlinks, safe-names, n…
determinismReportboolean–true adds `determinismReport`: zipnative's analyzeDeterminism() verdict in full — the stricter canonical form canonicalize_zip produces (also Zip64-only extras and the constant version-made-by) and e…
fieldsarray–Dot-paths to keep, after verbosity (e.g. ['entryCount', 'entries.name']); unmatched ones are listed in _meta.unmatchedFields.
limitsobject–Per-call override of zipnative's security bounds (CWE-400/409); absent keys keep the engine defaults (describe_engine.defaultLimits). A value above its operator ceiling is LIMIT_CEILING_EXCEEDED. Rai…
strictboolean–Turn the first engine diagnostic into a ZIP_STRICT_DIAGNOSTIC error.
validatestring–'eager' (default) cross-checks every local header and the overlap table up front — hostile shapes are refused here; 'lazy' defers to first read (cheaper on huge archives).
verbositystring–'summary': scalar verdict fields only (the token-frugal form).
zipBase64string–Archive bytes, base64 (≤ 128 MiB decoded). Exclusive with zipPath.
zipPathstring–Archive path relative to the ZIPNATIVE_MCP_OUTPUT_DIR sandbox (container extensions: .zip .jar .docx .epub …). Exclusive with zipBase64; saves re-sending bytes between calls.
NameTypeReqDescription
accessstring–Present when the archive was read by byte ranges (access 'range', or a zipPath above the in-memory cap): `determinism` is then absent and the determinism checks fail with that reason.
archiveBytesinteger––
canonicalLayoutboolean–summary only: buffered (no data descriptor) layout.
checksarray––
checksPassedboolean–Present when check / assert was supplied: true when every assertion holds.
commentstring–Archive comment (UTF-8, lossy).
commentBytesinteger––
commentHexstring––
compressedBytesinteger––
cp437NameCountinteger––
dataDescriptorCountinteger––
determinismobject–`deterministic` = reproducible (epoch timestamps + canonical order + UTF-8 flags); `canonicalLayout` = the buffered layout (no data descriptors) — a streamed archive is reproducible but not canonical.
determinismReportobject–Present with determinismReport: true — zipnative's analyzeDeterminism() report. `deterministic` here is the engine's canonical form (stricter than determinism.deterministic: also no extra field but Z…
deterministicboolean–summary only: the determinism verdict.
diagnosticCountinteger–summary only: number of distinct diagnostics.
diagnosticCountsobject–Occurrences per code, duplicates included.
diagnosticsarray–Non-fatal engine concerns (de-duplicated by code + entry, ≤ 200; codes in describe_engine.diagnosticCodes). Empty for a clean archive.
diagnosticsTruncatedboolean–true when rows beyond 200 were dropped.
directoryCountinteger––
duplicateNameCountinteger––
earliestDatestring|null––
encryptedCountinteger––
entryCountinteger––
fileCountinteger––
isZip64boolean–A Zip64 end-of-central-directory record is present.
latestDatestring|null––
methodsarray––
multipleEocdboolean––
prependedDataboolean–SFX-style prefix before the first local header (offsets shifted).
ratiostring––
symlinkCountinteger––
uncompressedBytesinteger––
unsafeNameCountinteger–Names sanitizeEntryPath() refuses (traversal, absolute, drive/UNC, NUL, ADS, device names).
utf8NameCountinteger––
zip64EntryCountinteger––

No examples provided.

list_zip_entries ~676

Read-only central-directory inventory without decompressing anything: every entry (duplicates included) in directory order as a full row — name + encoding, sizes, ratio, CRC-32, method, timestamp, decoded flags, Unix mode, symlink, Zip64, data descriptor, host system, offsets, named extra fields, the sanitized path an extraction would use (null = unsafe name), comment. `filter` selects by exact names / prefix / globs; `offset` + `limit` page (default 200, max 2000, `hasMore`). Prefer inspect_zip for a one-shot summary and read_zip_entry / extract_zip for content. Token-frugal: verbosity:'summary' → names only; fields:[…].

NameTypeReqDescription
accessstring–'auto' (default): in memory, and a zipPath above 1073741824 bytes by byte ranges. 'range': always by byte ranges over the sandbox file (never a URL; memory ≈ the central directory). 'memory': always…
fieldsarray–Dot-paths to keep, after verbosity (e.g. ['entryCount', 'entries.name']); unmatched ones are listed in _meta.unmatchedFields.
filterobject–Select entries: `names` (exact), `prefix`, `glob` (`*` in a segment, `**` across, `?`, `[a-z]`; no `/` = any depth, trailing `/` = subtree), ANDed; `includeDirectories` (default false).
includeExtendedTimestampsboolean–Add each entry's `extendedTimestamps` (zipnative getExtendedTimestamps: UT, then NTFS, then the DOS fields; ISO-8601, UTC).
includeExtraDataboolean–Include each extra field payload as base64 (forensics).
includeUnixIdsboolean–Add each entry's `unixIds` (zipnative getUnixIds: the Info-ZIP ux uid / gid, or null).
limitinteger–Return at most this many entries (default 200, max 2000); `hasMore` tells you to page.
limitsobject–Per-call override of zipnative's security bounds (CWE-400/409); absent keys keep the engine defaults (describe_engine.defaultLimits). A value above its operator ceiling is LIMIT_CEILING_EXCEEDED. Rai…
offsetinteger–Skip this many matching entries (paging).
strictboolean–Turn the first engine diagnostic into a ZIP_STRICT_DIAGNOSTIC error.
validatestring–'lazy' (default) parses the central directory only; 'eager' also cross-checks every local header up front.
verbositystring–'summary': scalar verdict fields only (the token-frugal form).
zipBase64string–Archive bytes, base64 (≤ 128 MiB decoded). Exclusive with zipPath.
zipPathstring–Archive path relative to the ZIPNATIVE_MCP_OUTPUT_DIR sandbox (container extensions: .zip .jar .docx .epub …). Exclusive with zipBase64; saves re-sending bytes between calls.
NameTypeReqDescription
accessstring–Present when the archive was read by byte ranges (access 'range', or a zipPath above the in-memory cap).
diagnosticCountinteger–summary only: number of distinct diagnostics.
diagnosticCountsobject–Occurrences per code, duplicates included.
diagnosticsarray–Non-fatal engine concerns (de-duplicated by code + entry, ≤ 200; codes in describe_engine.diagnosticCodes). Empty for a clean archive.
diagnosticsTruncatedboolean–true when rows beyond 200 were dropped.
entriesarray––
entryCountinteger–Entries in the central directory (before filtering).
hasMoreboolean––
isZip64boolean––
limitinteger––
matchedCountinteger–Entries kept by the filter (before paging).
namesarray–summary only: the names on this page.
offsetinteger––
returnedCountinteger––

No examples provided.

merge_zip ~704

Merge 1–32 archives into one WITHOUT recompressing anything: zipnative's addFromReader() transplants each entry's compressed bytes with its method, CRC, sizes, timestamp, attributes, comment and extra fields, in O(bytes copied). Each source is zipBase64 XOR zipPath with an optional filter. Every entry is CRC- and size-checked before it is copied (verify, default true), so a corrupt payload is refused with its ZIP_* code instead of being propagated; an entry whose method has no codec here (ZIP_UNSUPPORTED_METHOD) and encrypted entries are refused. A foreign name the writer will not accept (e.g. a bsdtar './'-prefixed entry) is ZIP_INVALID_ENTRY_NAME — exclude it with that source's filter. Name collisions: onConflict 'error' (default, ZIP_DUPLICATE_ENTRY_NAME), 'first' or 'last' (summary.dropped lists what was not kept). order 'canonical' (default) sorts like create_zip. Run canonicalize_zip on the result for the full canonical form. Output base64 or a sandbox file (streamed).

NameTypeReqDescription
commentstring–Archive comment of the result (UTF-8, ≤ 65535 bytes). Default none — the sources' comments are not merged.
includeSha256boolean–Add `summary.sha256` of the produced bytes.
limitsobject–Per-call override of zipnative's security bounds (CWE-400/409); absent keys keep the engine defaults (describe_engine.defaultLimits). A value above its operator ceiling is LIMIT_CEILING_EXCEEDED. Rai…
onConflictstring–Two entries with the same name: 'error' (default) — the engine refuses the second with ZIP_DUPLICATE_ENTRY_NAME; 'first' / 'last' — keep the first / last occurrence across the sources in order, the o…
orderstring–'canonical' (default): entries sorted by raw name bytes, as create_zip writes them; 'insertion': the sources' order, then each source's central-directory order.
outputModestring–'base64' (default): inline embedded resource (≤ 50 MiB; the bytes appear in both its data: uri and its blob). 'file': written into the sandbox (never overwrites; ≤ ZIPNATIVE_MCP_MAX_FILE_OUTPUT_BYTES…
outputPathstring–Relative path inside the sandbox (only when outputMode='file'); must end in a container extension (.zip recommended).
sourcesarrayyesThe archives to merge, in order (1–32; total ≤ 1073741824 bytes, inline payloads ≤ 134217728 bytes in all). Each is zipBase64 XOR zipPath, with an optional filter selecting the entries taken from it…
strictboolean–Turn the first engine diagnostic into a ZIP_STRICT_DIAGNOSTIC error.
verifyboolean–Decompress each entry once to check its CRC and size before copying it (secure by default: a corrupt entry is refused with ZIP_CRC_MISMATCH / ZIP_SIZE_MISMATCH instead of being propagated). false tru…
NameTypeReqDescription
diagnosticCountsobject–Occurrences per code, duplicates included.
diagnosticsarrayyesNon-fatal engine concerns (de-duplicated by code + entry, ≤ 200; codes in describe_engine.diagnosticCodes). Empty for a clean archive.
diagnosticsTruncatedboolean–true when rows beyond 200 were dropped.
filePathstring–Sandboxed absolute path (file mode).
modestringyes–
sizeBytesintegeryes–
summaryobjectyesmerge_zip summary.

No examples provided.

modify_zip ~983

Edit an existing archive without recompressing anything: operations add / replace / remove / rename / setComment applied in order. mode 'append' (default) = save(): the original bytes stay verbatim and edits are appended — fast and byte-preserving, BUT removed or replaced payloads REMAIN in the file (data remanence: recoverable by anyone; a ZIP_DEAD_BYTES_RATIO diagnostic fires past 50 % dead bytes, and 7-Zip is known to read the stale payload). mode 'compact' = saveCompact(): a rewrite without the dead bytes, entries SORTED by raw name bytes (an insertion-ordered layout — EPUB mimetype first, JAR manifest first — is not kept; 'append' keeps it), still no recompression, removed data truly gone, SFX prefix dropped; add `canonical: {…}` for the canonical deterministic form (zipnative 1.1.0, the canonicalize_zip rules applied after the edits). No edits and an unchanged comment return the same bytes (`summary.noOp`). The input is opened eagerly and, in 'append' mode, every entry is cross-checked against its local header and declared sizes before its bytes are re-emitted (ZIP_ENTRY_OVERLAP / ZIP_CD_LFH_MISMATCH / ZIP_LIMIT_EXCEEDED). Entry names travel verbatim (an unsafe name stays unsafe — extract_zip sanitises on the way out). Archives with duplicate entry names are refused — prefer create_zip for a full rebuild or when the source has duplicate names. Output base64 or a sandbox file.

NameTypeReqDescription
canonicalobject–mode 'compact' only (zipnative 1.1.0 saveCompact({ canonical })): after the edits, rewrite every entry into the canonical deterministic form — sorted by raw name bytes, one timestamp, UTF-8 flags, Zi…
compressionobject–Compression settings. `method` 'deflate' (default) or 'store'; `level` 0–9 (default 6); `deterministic: true` pins the pure-TS encoder so the bytes are identical on every runtime (slower).
defaultDatestring–Timestamp for entries that set no `date`: an ISO-8601 instant (1980-01-01 … 2107-12-31, 2-second DOS granularity) or 'now' (wall clock — emits the ZIP_TIMESTAMP_NOT_PINNED diagnostic and makes the by…
includeSha256boolean–Add `summary.sha256` of the produced bytes.
limitsobject–Per-call override of zipnative's security bounds (CWE-400/409); absent keys keep the engine defaults (describe_engine.defaultLimits). A value above its operator ceiling is LIMIT_CEILING_EXCEEDED. Rai…
modestring–'append' (default): save() — original bytes verbatim + appended entries + new central directory; removed/replaced payloads REMAIN in the file (data remanence). 'compact': saveCompact() — a rewrite wi…
operationsarrayyesEdits applied in order. add: new entry (ZIP_ENTRY_EXISTS if present); replace: existing entry (ZIP_ENTRY_NOT_FOUND otherwise); remove; rename (never overwrites: remove the target first); setComment.
outputModestring–'base64' (default): inline embedded resource (≤ 50 MiB; the bytes appear in both its data: uri and its blob). 'file': written into the sandbox (never overwrites; ≤ ZIPNATIVE_MCP_MAX_FILE_OUTPUT_BYTES…
outputPathstring–Relative path inside the sandbox (only when outputMode='file'); must end in a container extension (.zip recommended).
strictboolean–Turn the first engine diagnostic into a ZIP_STRICT_DIAGNOSTIC error.
zipBase64string–Archive bytes, base64 (≤ 128 MiB decoded). Exclusive with zipPath.
zipPathstring–Archive path relative to the ZIPNATIVE_MCP_OUTPUT_DIR sandbox (container extensions: .zip .jar .docx .epub …). Exclusive with zipBase64; saves re-sending bytes between calls.
NameTypeReqDescription
diagnosticCountsobject–Occurrences per code, duplicates included.
diagnosticsarrayyesNon-fatal engine concerns (de-duplicated by code + entry, ≤ 200; codes in describe_engine.diagnosticCodes). Empty for a clean archive.
diagnosticsTruncatedboolean–true when rows beyond 200 were dropped.
filePathstring–Sandboxed absolute path (file mode).
modestringyes–
sizeBytesintegeryes–
summaryobjectyesmodify_zip summary.

No examples provided.

read_zip_entry ~727

Read ONE entry without extracting the archive, by `name` (exact; the last duplicate wins) or `index` (central-directory position — disambiguates duplicates). mode 'data' (default): decompressed content as base64 or UTF-8 `text` (encoding:'utf8'; ENTRY_NOT_UTF8 otherwise), CRC-verified; a `range` {offset,length} reads a byte window through the chunked stream (bounded memory, no CRC). mode 'raw': the compressed payload verbatim (feed it to inflate_raw). mode 'verify': CRC / size / local-header agreement only. Inline cap 16 MiB per entry (ENTRY_TOO_LARGE → use a range or extract_zip file mode). Encrypted entries → ZIP_UNSUPPORTED_ENCRYPTION (no decryption in this engine).

NameTypeReqDescription
accessstring–'auto' (default): in memory, and a zipPath above 1073741824 bytes by byte ranges. 'range': always by byte ranges over the sandbox file (never a URL; memory ≈ the central directory). 'memory': always…
encodingstring–Content encoding for mode 'data': base64 (default) or UTF-8 text (invalid UTF-8 → ENTRY_NOT_UTF8).
fieldsarray–Dot-paths to keep, after verbosity (e.g. ['entryCount', 'entries.name']); unmatched ones are listed in _meta.unmatchedFields.
includeExtendedTimestampsboolean–Add the entry's `extendedTimestamps` (zipnative getExtendedTimestamps: UT, then NTFS, then the DOS fields; ISO-8601, UTC).
includeUnixIdsboolean–Add the entry's `unixIds` (zipnative getUnixIds: the Info-ZIP ux uid / gid, or null).
indexinteger–Central-directory position (from list_zip_entries) — disambiguates duplicate names. Exclusive with name.
limitsobject–Per-call override of zipnative's security bounds (CWE-400/409); absent keys keep the engine defaults (describe_engine.defaultLimits). A value above its operator ceiling is LIMIT_CEILING_EXCEEDED. Rai…
modestring–'data' (default): decompressed content; 'raw': the compressed payload bytes verbatim (zero-copy, no decompression); 'verify': CRC / size / local-header check only, no payload.
namestring–Entry name (exact, case-sensitive; the LAST duplicate wins). Exclusive with index.
rangeobject–Read only a byte window of the decompressed content through the chunked stream (bounded memory; CRC is not verified for a window). length ≤ 16777216.
strictboolean–Turn the first engine diagnostic into a ZIP_STRICT_DIAGNOSTIC error.
verbositystring–'summary': scalar verdict fields only (the token-frugal form).
verifyCrcboolean–Verify the decompressed CRC-32 against the central directory (mode data, no range).
zipBase64string–Archive bytes, base64 (≤ 128 MiB decoded). Exclusive with zipPath.
zipPathstring–Archive path relative to the ZIPNATIVE_MCP_OUTPUT_DIR sandbox (container extensions: .zip .jar .docx .epub …). Exclusive with zipBase64; saves re-sending bytes between calls.
NameTypeReqDescription
accessstring–Present when the archive was read by byte ranges (access 'range', or a zipPath above the in-memory cap).
crcVerifiedboolean––
dataBase64string––
diagnosticCountinteger–summary only: number of distinct diagnostics.
diagnosticCountsobject–Occurrences per code, duplicates included.
diagnosticsarray–Non-fatal engine concerns (de-duplicated by code + entry, ≤ 200; codes in describe_engine.diagnosticCodes). Empty for a clean archive.
diagnosticsTruncatedboolean–true when rows beyond 200 were dropped.
encodingstring––
entryobject––
indexinteger–summary only: the entry index.
modestring––
namestring–summary only: the entry name.
rangeobject––
sizeBytesinteger–Bytes returned (data / raw) or the declared uncompressed size (verify).
textstring––
textLengthinteger––
verificationobject––

No examples provided.

sanitize_entry_paths ~187

Apply zipnative's single traversal gate `sanitizeEntryPath()` to a list of names: the safe '/'-separated relative form each maps to (join it under your extraction root — never the raw name), or null with the rule that fired (empty, NUL byte, absolute, drive letter, UNC, '..' traversal, NTFS alternate data stream ':', Windows reserved device name CON/NUL/COM1…). Use it when you extract with another tool or plan an external filesystem sink. No archive needed.

NameTypeReqDescription
fieldsarray–Dot-paths to keep, after verbosity (e.g. ['entryCount', 'entries.name']); unmatched ones are listed in _meta.unmatchedFields.
namesarrayyesEntry names to check (as stored in an archive).
verbositystring–'summary': scalar verdict fields only (the token-frugal form).
NameTypeReqDescription
countinteger––
rejectedCountinteger––
rejectedNamesarray–summary only: the rejected names.
resultsarray––

No examples provided.

scan_zip_forward ~630

Walk LOCAL headers in stream order with bounded memory (zipnative's central-directory-less reader). The only tool that works on a truncated archive or a stream cut mid-way (it cannot skip an SFX prefix: the stream must start at a local header) — and the only one whose result is NOT authoritative: forward iteration trusts local headers ALONE, so a hostile archive can present different content here than inspect_zip / list_zip_entries report (the upload-scanner differential). Prefer those tools whenever the whole archive is available; use this one for forensics (`tolerateTruncation:true` returns the partial inventory + `error`). data 'none' skips payloads, 'verify' decompresses to check CRCs, 'include' returns them (inline caps). `stoppedAt` tells you whether a central directory was reached. Names are NOT sanitized — `sanitizedPath` shows what the extraction gate would use.

NameTypeReqDescription
datastring–'none' (default): skip payloads (a data-descriptor entry still costs a full decompress-and-discard); 'verify': decompress every kept entry so CRC and sizes are checked; 'include': also return the con…
fieldsarray–Dot-paths to keep, after verbosity (e.g. ['entryCount', 'entries.name']); unmatched ones are listed in _meta.unmatchedFields.
filterobject–Select entries: `names` (exact), `prefix`, `glob` (`*` in a segment, `**` across, `?`, `[a-z]`; no `/` = any depth, trailing `/` = subtree), ANDed; `includeDirectories` (default false).
limitsobject–Per-call override of zipnative's security bounds (CWE-400/409); absent keys keep the engine defaults (describe_engine.defaultLimits). A value above its operator ceiling is LIMIT_CEILING_EXCEEDED. Rai…
maxEntriesinteger–Stop after this many local headers (bounded work on an unbounded stream). Default 10000, clamped to the operator ceiling ZIPNATIVE_MCP_MAX_ENTRIES; an explicit value above the ceiling is refused (LIM…
strictboolean–Turn the first engine diagnostic into a ZIP_STRICT_DIAGNOSTIC error.
tolerateTruncationboolean–true: a truncated / corrupt stream ends the scan with `stoppedAt:"error"` and the partial inventory (forensics) instead of failing the call.
verbositystring–'summary': scalar verdict fields only (the token-frugal form).
zipBase64string–Archive bytes, base64 (≤ 128 MiB decoded). Exclusive with zipPath.
zipPathstring–Archive path relative to the ZIPNATIVE_MCP_OUTPUT_DIR sandbox (container extensions: .zip .jar .docx .epub …). Exclusive with zipBase64; saves re-sending bytes between calls.
NameTypeReqDescription
bytesDeliveredinteger–Bytes handed to the forward reader.
diagnosticCountinteger–summary only: number of distinct diagnostics.
diagnosticCountsobject–Occurrences per code, duplicates included.
diagnosticsarray–Non-fatal engine concerns (de-duplicated by code + entry, ≤ 200; codes in describe_engine.diagnosticCodes). Empty for a clean archive.
diagnosticsTruncatedboolean–true when rows beyond 200 were dropped.
entriesarray––
entryCountinteger–Local headers seen (before the filter).
errorobject––
inputBytesinteger|null––
keptCountinteger––
maxEntriesinteger–The header budget in force (after clamping to the operator ceiling).
namesarray–summary only: the kept entry names.
stoppedAtstring–'central-directory' is the normal end of a complete archive; 'eof' means the stream ended before any central directory (truncated or CD-less); 'max-entries' means more local headers remained.
truncatedboolean–true when the stream ended without reaching a central directory.
truststring–Constant reminder: nothing here was cross-checked against a central directory.

No examples provided.

verify_zip ~505

Deep verification in one call — zipnative's verifyZip report verbatim: eager structural validation, then every entry's CRC-32 / size / local-header agreement. `ok` is true when the structure is valid AND every verifiable entry passed AND every design-time skip ('encrypted' | 'stream-only-codec') has a local header that agrees with the central directory. This tool NEVER fails for a problem with the archive: a structural refusal lands in `error` {code: ZIP_*, message}; each row carries `skipped` with the reason its payload was not verified — a design-time skip with an agreeing local header counts in skippedCount and does not fail the archive; an entry whose method has no codec here (skipped: 'unsupported-method') or an encrypted entry whose local header contradicts the central directory is FAILED — the engine's verdict verbatim. Only caller mistakes (bad limits, bad input) are isError. `entries:'failed'` keeps the rows you act on; `verbosity:'summary'` keeps the verdict + counts. Verify before you trust: run it on any archive from an untrusted source before extract_zip.

NameTypeReqDescription
entriesstring–Which per-entry rows to return: 'all' (default), only 'failed' (ok:false, not skipped), only 'skipped', or 'none' (verdict + counts only).
fieldsarray–Dot-paths to keep, after verbosity (e.g. ['entryCount', 'entries.name']); unmatched ones are listed in _meta.unmatchedFields.
limitsobject–Per-call override of zipnative's security bounds (CWE-400/409); absent keys keep the engine defaults (describe_engine.defaultLimits). A value above its operator ceiling is LIMIT_CEILING_EXCEEDED. Rai…
maxEntriesinteger–Cap on returned rows (the counts always cover every entry); `entriesTruncated` flags a cut.
verbositystring–'summary': scalar verdict fields only (the token-frugal form).
zipBase64string–Archive bytes, base64 (≤ 128 MiB decoded). Exclusive with zipPath.
zipPathstring–Archive path relative to the ZIPNATIVE_MCP_OUTPUT_DIR sandbox (container extensions: .zip .jar .docx .epub …). Exclusive with zipBase64; saves re-sending bytes between calls.
NameTypeReqDescription
diagnosticCountinteger–summary only: number of diagnostics.
diagnosticsarray–Non-fatal engine concerns (de-duplicated by code + entry, ≤ 200; codes in describe_engine.diagnosticCodes). Empty for a clean archive.
diagnosticsTruncatedboolean–Present (true) when more than 200 distinct diagnostics were raised and the list was cut.
entriesarray––
entriesTruncatedboolean––
entryCountinteger––
errorobject|null–The structural refusal when the archive could not even be opened (frozen ZIP_* code + engine message), else null.
failedCountinteger–Entries that fail the archive: a CRC / size / local-header mismatch, an unknown compression method, or a design-time skip whose local header contradicts the central directory.
okboolean––
skippedCountinteger–Entries that could not be verified by design (encrypted, stream-only codec) and whose local header agrees with the central directory.
verifiedCountinteger–Entries that passed every check.

No examples provided.

Install

How do I install the zipnative MCP — ZIP creation, inspection, secure… server?

zipnative MCP — ZIP creation, inspection, secure… runs locally as an npm package, launched with npx -y zipnative-mcp. The registry lists runner options for this package that are not in this command (they are not ones we reproduce, or they name another package). Check the registry entry before relying on it. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

npm · zipnative-mcp

# add to Claude Code
claude mcp add nizoka-zipnative-mcp -- npx -y zipnative-mcp

The registry lists runner options for this package that are not in this command (they are not ones we reproduce, or they name another package). Check the registry entry before relying on it.

Common questions

What is the zipnative MCP — ZIP creation, inspection, secure… server?

zipnative MCP — ZIP creation, inspection, secure… is listed in the public MCP registry as io.github.Nizoka/zipnative-mcp. ZIP MCP server: create, inspect, verify, extract, canonicalize, merge, modify. 15 tools. This page covers its npm package (zipnative-mcp).

Is the zipnative MCP — ZIP creation, inspection, secure… server safe to use?

zipnative MCP — ZIP creation, inspection, secure… scores 95 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 22 November 2026. It declares no install or post-install scripts. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

What tools does the zipnative MCP — ZIP creation, inspection, secure… server expose?

zipnative MCP — ZIP creation, inspection, secure… exposes 15 tools: inspect_zip, list_zip_entries, read_zip_entry, verify_zip, extract_zip, and 10 more. Their descriptions and schemas cost roughly 9,107 tokens of context every time the server is loaded.

Is the zipnative MCP — ZIP creation, inspection, secure… server still maintained?

zipnative MCP — ZIP creation, inspection, secure… is still listed as active in the MCP registry. We last reached this channel on 22 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

What licence is the zipnative MCP — ZIP creation, inspection, secure… server under?

zipnative MCP — ZIP creation, inspection, secure… declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

What did VerifyMCP test on the zipnative MCP — ZIP creation, inspection, secure… server?

VerifyMCP ran 16 checks on zipnative MCP — ZIP creation, inspection, secure…, covering Malware scan, Known CVEs, Install scripts, Dependency health and 12 more. Endpoint Security and Transport & Reachability do not apply to an npm package, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.