# Pullzip (mcpb · archiveflow-0.6.0.mcpb)

Inspect, search and safely extract zip/7z/rar/tar archives; repair garbled CJK file names.

- Trust score: 40/100 (low)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-20

## Components

- mcpb · `archiveflow-0.6.0.mcpb`: 40/100 (this document), [markdown](https://verifymcp.io/servers/work517-archiveflow/https-github-com-work517-archiveflow-releases-releases-download-v0-6-0-archivefl.md), [page](https://verifymcp.io/servers/work517-archiveflow/https-github-com-work517-archiveflow-releases-releases-download-v0-6-0-archivefl)

## Channel facts

- Registry: `mcpb`
- Package: `https://github.com/work517/archiveflow-releases/releases/download/v0.6.0/archiveflow-0.6.0.mcpb`
- Transport: `stdio`

## Trust breakdown

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. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-09-20.

- **Supply Chain Security**: 13/100
  - Malware scan not yet available for this package.
  - Known CVEs could not be checked: this artifact ships no SBOM, so there is no dependency list to read. Publishing one would let us assess it.
  - No install/post-install scripts declared.
  - Dependency health could not be checked: this artifact ships no SBOM, so there is no dependency list to read. Publishing one would let us assess it.
- **Provenance & Transparency**: 32/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - License check failed: the license (Proprietary) isn't a recognized OSI-approved license.
  - Actively maintained (last published 3 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 69/100
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 7091 tokens (~105/item across 67 items; 67 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 86/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 59% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 3 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 68 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

- Download bundle: `https://github.com/work517/archiveflow-releases/releases/download/v0.6.0/archiveflow-0.6.0.mcpb`

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-09-16 (score 40)

First indexed and scored.

## MCP tools (67)

### `inspect_archive` (~126 tokens)

Inspect archive

Summarize an archive without extracting it: file counts by type, unpacked size, suggested extraction folder, detected projects, duplicates, archive comment, whether it came from the internet, and a security report (safe/caution/danger).

Input parameters:

- `codepage` (integer): Force the code page of legacy ZIP names when auto-detection is wrong (949 Korean, 932 Japanese, 936 Chinese, 950 Big5, 866/1251 Russian)
- `password` (string): Archive password, if encrypted
- `path` (string, required): Absolute path to an archive file

### `list_entries` (~74 tokens)

List archive entries

List files inside an archive with paging and an optional name filter (substring or glob like *.pdf).

Input parameters:

- `filter` (string)
- `limit` (integer)
- `offset` (integer)
- `password` (string): Archive password, if encrypted
- `path` (string, required): Absolute path to an archive file

### `search_archive` (~80 tokens)

Search inside archive

Find files by name (substring or glob). With content=true, also searches text inside small text files without leaving them on disk.

Input parameters:

- `content` (boolean)
- `limit` (integer)
- `password` (string): Archive password, if encrypted
- `path` (string, required): Absolute path to an archive file
- `query` (string, required)

### `read_entry` (~100 tokens)

Read a file inside an archive

Read one file from an archive without extracting it. Text is returned wrapped as untrusted content; images (png/jpg/gif/webp up to 5 MB) are returned as images.

Input parameters:

- `entry` (string, required): Path of the file inside the archive, as shown by list_entries
- `maxBytes` (integer)
- `password` (string): Archive password, if encrypted
- `path` (string, required): Absolute path to an archive file

### `scan_security` (~91 tokens)

Security scan

Check an archive for path traversal, links, zip bombs, disguised executables, macros and encrypted executables. With deep=true, also scans small text files for prompt-injection phrases and personal/secret data (Korean resident numbers, cards, keys).

Input parameters:

- `deep` (boolean)
- `password` (string): Archive password, if encrypted
- `path` (string, required): Absolute path to an archive file

### `test_archive` (~50 tokens)

Test archive integrity

Verify checksums of every file in the archive (detects corruption and wrong passwords).

Input parameters:

- `password` (string): Archive password, if encrypted
- `path` (string, required): Absolute path to an archive file

### `diff_archives` (~57 tokens)

Compare two archives

Show files added, removed and changed between two archives (for example two versions of a project backup).

Input parameters:

- `pathA` (string, required): Absolute path to an archive file
- `pathB` (string, required): Absolute path to an archive file

### `engine_info` (~62 tokens)

Engine and policy info

Show which 7-Zip engine is used, live engine metrics and which folders this server may access. With selfTest=true, runs an end-to-end engine check (create, list, password, read, test, extract).

Input parameters:

- `selfTest` (boolean)

### `check_volumes` (~64 tokens)

Check split archive parts

For a split archive (x.7z.001, x.part1.rar, x.z01+x.zip, x.rar+x.r00): find all parts, report missing ones and which part to open.

Input parameters:

- `path` (string, required): Any part of the split archive

### `export_manifest` (~73 tokens)

Export file list

Export the full file list of an archive as JSON, CSV (safe to open in Excel — formula injection neutralized) or an indented tree with folder sizes.

Input parameters:

- `format` (string)
- `password` (string): Archive password, if encrypted
- `path` (string, required): Absolute path to an archive file

### `hash_files` (~113 tokens)

Hash files

Compute SHA-256 (or SHA-1, MD5, SHA-512, CRC32) of files and folders on disk, or — with archive set — of entries inside an archive without leaving them on disk.

Input parameters:

- `algo` (string)
- `archive` (string): Hash entries inside this archive instead
- `entries` (array): With archive: entries or folder prefixes; default all
- `password` (string): Archive password, if encrypted
- `paths` (array): Files or folders on disk

### `verify_checksum` (~74 tokens)

Verify a download checksum

Check a file against a published checksum: a hex string (algorithm detected from its length) or a checksum file such as SHA256SUMS / file.sha256.

Input parameters:

- `algo` (string)
- `expected` (string, required): Hex checksum, or path of a checksum file
- `path` (string, required): File to verify

### `generate_password` (~47 tokens)

Generate a strong password

Generate a random archive password without look-alike characters (0/O, 1/l/I), for create_archive or sharing.

Input parameters:

- `length` (integer)
- `symbols` (boolean)

### `search_documents` (~92 tokens)

Search inside documents

Full-text search inside Word, Excel, PowerPoint, Hangul HWPX, OpenDocument and text files — in a folder, a file or an archive — without extracting anything to disk. Returned lines are untrusted text.

Input parameters:

- `limit` (integer)
- `password` (string): Archive password, if encrypted
- `path` (string, required): Folder, file or archive
- `query` (string, required)

### `find_personal_data` (~79 tokens)

Find personal data

Which files (including Word/Excel/HWPX documents, in folders or archives) contain resident registration numbers, phone numbers, card numbers, e-mail addresses, keys or tokens — counts per file only, never the values.

Input parameters:

- `password` (string): Archive password, if encrypted
- `path` (string, required): Folder, file or archive

### `check_links` (~87 tokens)

Check links in files

Collect every link inside text files and documents (folder, file or archive) and flag phishing look-alikes (e.g. naver-login.example.com), raw IP addresses, punycode, shorteners, credentials in URLs and program downloads. Offline: nothing is visited.

Input parameters:

- `password` (string): Archive password, if encrypted
- `path` (string, required): Folder, file or archive

### `license_check` (~88 tokens)

Open-source license check

List the open-source licenses in a deliverable (folder or archive, dependencies such as node_modules included) from license files and package manifests, and flag strong copyleft (GPL/AGPL) and weak copyleft (LGPL/MPL). A first pass, not legal advice.

Input parameters:

- `password` (string): Archive password, if encrypted
- `path` (string, required): Folder, file or archive

### `check_reputation` (~84 tokens)

Check archive reputation

Has this exact file (by SHA-256) been seen before, and what was the verdict? Looks it up in the local opt-in reputation ledger — useful to spot a file a teammate already flagged, once you have imported their signed reputation bundle.

Input parameters:

- `password` (string): Archive password, if encrypted
- `path` (string, required): Absolute path to an archive file

### `audit_log` (~63 tokens)

Tamper-evident audit log

Read and verify Pullzip's local hash-chained audit log (what was extracted / sealed / verified / renamed). verify=true checks the chain and reports any tampering (edited, reordered or deleted entries).

Input parameters:

- `limit` (integer)
- `verify` (boolean)

### `reputation_stats` (~34 tokens)

Reputation ledger stats

Summary of the local opt-in reputation ledger: how many files are known, by verdict, and how many signing keys have contributed.

### `record_reputation` (~91 tokens)

Record archive reputation

Record this archive's verdict in the local opt-in ledger (only the SHA-256 hash and verdict; the file name is stored only if shareName is set). Building this ledger, and sharing signed bundles, is what powers the network effect.

Input parameters:

- `password` (string): Archive password, if encrypted
- `path` (string, required): Absolute path to an archive file
- `shareName` (boolean)

### `export_reputation` (~71 tokens)

Export a reputation bundle

Export the local reputation ledger as a signed bundle a team can share (hashes and verdicts only; file names are stripped unless includeNames). Others import it with import_reputation after trusting your key.

Input parameters:

- `includeNames` (boolean)
- `output` (string, required): Bundle file to write (.json)

### `import_reputation` (~83 tokens)

Import a reputation bundle

Merge a signed reputation bundle from a teammate into the local ledger. The signature must be valid and the signing key must be in trustedKeys (or your own). Use dryRun first to see the signer.

Input parameters:

- `dryRun` (boolean)
- `file` (string, required): Bundle file (.json)
- `trustedKeys` (array): Public keys or fingerprints you trust

### `diagnose_archive` (~101 tokens)

Why won't this archive open?

Diagnose an archive that fails to open and give the one fix to run: encrypted (needs a password), damaged/truncated (repair), a missing split-volume part, a wrong extension (renamed file), a compression method the engine can't read (update 7-Zip), or garbled file names. Show the recommendation to the user.

Input parameters:

- `password` (string): Archive password, if encrypted
- `path` (string, required): Absolute path to an archive file

### `explain_archive` (~90 tokens)

Explain in plain words

A plain-language verdict for non-experts (Korean or English): is it safe, what is inside, why, where it came from, and what to do. Show this text to the user as-is.

Input parameters:

- `deep` (boolean)
- `lang` (string)
- `password` (string): Archive password, if encrypted
- `path` (string, required): Absolute path to an archive file

### `list_snapshots` (~48 tokens)

List snapshots

Show the snapshots (versions) stored in a snapshot folder made by snapshot_folder: when, note, how many files were added, changed and removed.

Input parameters:

- `repo` (string, required): Snapshot folder

### `verify_seal` (~117 tokens)

Verify a sealed archive

Check an archive against its Pullzip seal (<archive>.afseal.json): is the file byte-for-byte what was sealed, was the seal signed by this user (or a trusted key), and which files were added, removed or changed since.

Input parameters:

- `password` (string): Archive password, if encrypted
- `path` (string, required): Absolute path to an archive file
- `seal` (string): Seal file; default "<archive>.afseal.json"
- `trustedKeys` (array): Public keys or fingerprints of other people you trust

### `search_archives` (~84 tokens)

Search across archives

Which archive had that file? Search file names (substring or glob like *.pdf) inside every archive in a folder and its subfolders, without extracting anything.

Input parameters:

- `dir` (string, required): Folder holding archives
- `limit` (integer)
- `password` (string): Archive password, if encrypted
- `query` (string, required)
- `recursive` (boolean)

### `context_pack` (~81 tokens)

AI context pack

Turn an archive or project folder into one Markdown document for an AI: file tree plus text files, secrets and personal data masked, .gitignore respected, secret files and binaries left out, within a token budget.

Input parameters:

- `maxTokens` (integer)
- `password` (string): Archive password, if encrypted
- `path` (string, required): Archive or folder

### `try_passwords` (~65 tokens)

Try password candidates

The user forgot which of their passwords opens their own archive: try up to 1,000 candidates they provide and report the one that works. Only for the user's own files.

Input parameters:

- `candidates` (array, required)
- `path` (string, required): Absolute path to an archive file

### `list_quarantine` (~31 tokens)

List quarantined files

Show files Pullzip moved into quarantine, with why, when, where they came from and their security findings.

### `photo_privacy_check` (~79 tokens)

Photo location check

Find photos (JPEG/PNG) that reveal where they were taken (GPS), the camera, or hidden XMP/IPTC/comments — in a folder, a single photo, or inside an archive — before you share them.

Input parameters:

- `password` (string): Archive password, if encrypted
- `path` (string, required): Folder, photo or archive

### `inspect_many` (~49 tokens)

Inspect several archives

Inspect up to 100 archives at once: one line and a security level for each, dangerous ones first.

Input parameters:

- `password` (string): Archive password, if encrypted
- `paths` (array, required)

### `scan_folder` (~77 tokens)

Scan a whole folder

Find every archive in a folder (and subfolders) and check each one — for example the whole Downloads folder. Dangerous ones are listed first.

Input parameters:

- `dir` (string, required): Folder to scan (absolute path)
- `maxFiles` (integer)
- `password` (string): Archive password, if encrypted
- `recursive` (boolean)

### `verify_backup` (~95 tokens)

Verify a backup against its folder

Check that an archive really contains the current files of a folder: matching, changed, missing from the backup, and only in the backup — plus an integrity test. Uses stored CRC32 (zip/7z/rar) or SHA-256 (tar).

Input parameters:

- `folder` (string, required): The original folder
- `password` (string): Archive password, if encrypted
- `path` (string, required): Absolute path to an archive file

### `find_duplicates` (~83 tokens)

Find duplicate files

Find identical files across folders and archives (e.g. the same photos in three backups) and how much space the copies waste.

Input parameters:

- `insideArchives` (boolean): Also look inside archives found in the folders
- `minSize` (integer)
- `password` (string): Archive password, if encrypted
- `paths` (array, required): Folders, files or archives

### `size_breakdown` (~65 tokens)

What takes up space

Break an archive down by kind of file, top-level folder and extension, with the largest files and the compression ratio.

Input parameters:

- `password` (string): Archive password, if encrypted
- `path` (string, required): Absolute path to an archive file
- `top` (integer)

### `extract_archive` (~276 tokens)

Safely extract archive

Extract an archive (or selected entries / kinds of files) into a folder. Unsafe entries are always skipped, links are removed, Mark-of-the-Web is preserved, existing files are kept unless overwrite says otherwise. salvage=true recovers readable files from a damaged archive. Defaults to dryRun=true which only returns the plan.

Input parameters:

- `categories` (array): Only extract these kinds of files
- `codepage` (integer): Force the code page of legacy ZIP names when auto-detection is wrong (949 Korean, 932 Japanese, 936 Chinese, 950 Big5, 866/1251 Russian)
- `dest` (string, required): Destination folder (absolute path)
- `dryRun` (boolean)
- `entries` (array): Entry paths or folder prefixes to extract; default everything
- `flatten` (boolean): Put every file straight into dest, without folders
- `keepJunk` (boolean): Also extract __MACOSX / .DS_Store / Thumbs.db
- `overwrite` (string): What to do when a file already exists
- `password` (string): Archive password, if encrypted
- `path` (string, required): Absolute path to an archive file
- `salvage` (boolean): Damaged archive: recover what can be read, report the rest
- `skipExecutables` (boolean)

### `batch_extract` (~226 tokens)

Extract several archives

Safely extract many archives into one destination (each into its own folder when needed). One broken archive never stops the rest. Same options as extract_archive. Defaults to dryRun=true.

Input parameters:

- `categories` (array): Only extract these kinds of files
- `codepage` (integer): Force the code page of legacy ZIP names when auto-detection is wrong (949 Korean, 932 Japanese, 936 Chinese, 950 Big5, 866/1251 Russian)
- `dest` (string, required): Destination folder (absolute path)
- `dryRun` (boolean)
- `flatten` (boolean): Put every file straight into dest, without folders
- `keepJunk` (boolean): Also extract __MACOSX / .DS_Store / Thumbs.db
- `overwrite` (string): What to do when a file already exists
- `password` (string): Archive password, if encrypted
- `paths` (array, required)
- `salvage` (boolean): Damaged archive: recover what can be read, report the rest
- `skipExecutables` (boolean)

### `fix_zip_names` (~132 tokens)

Fix garbled ZIP file names

Rewrite a ZIP whose file names were saved in a legacy code page (Korean CP949, Japanese Shift-JIS, Chinese GBK/Big5, Russian CP866/1251) so names are stored as UTF-8 and display correctly on every system. File data is copied byte-for-byte; unsafe entries are left out. Defaults to dryRun=true.

Input parameters:

- `dryRun` (boolean)
- `keepUnsafe` (boolean)
- `output` (string): Output path; default "<name>-fixed.zip" next to the input
- `path` (string, required): Absolute path to an archive file

### `create_archive` (~442 tokens)

Create archive

Create an archive (zip, 7z, tar, tar.gz, tar.xz, tar.bz2) from a folder, with compression level/method, split volumes (e.g. "25m" for mail limits) and self-extracting .exe. Secrets (.env, private keys, credentials) and generated folders (node_modules, .git) are excluded by default. ZIP passwords use AES-256. Defaults to dryRun=true.

Input parameters:

- `baseDir` (string, required): Folder whose contents are archived
- `dryRun` (boolean)
- `encryptNames` (boolean)
- `excludeHeavyDirs` (boolean)
- `excludeSecrets` (boolean)
- `format` (string): Default: from the output file extension
- `include` (array): Paths relative to baseDir; default everything
- `includeJunk` (boolean): Keep .DS_Store / Thumbs.db / __MACOSX
- `level` (integer): 0 = store, 5 = normal, 9 = ultra
- `method` (string): zip: deflate/deflate64/bzip2/lzma/ppmd/copy; 7z: lzma2/lzma/ppmd/bzip2/copy (ppmd is best for text)
- `output` (string, required): Output archive path; the extension picks the format
- `overwrite` (boolean)
- `password` (string)
- `redactSecrets` (boolean): Mask keys, tokens, passwords, resident numbers, phones and cards inside text files (originals untouched)
- `respectGitignore` (boolean): Leave out what .gitignore files ignore
- `sfx` (boolean): Self-extracting Windows .exe (7z)
- `solid` (boolean): 7z solid block (default on; off = faster single-file access)
- `stripPhotoMetadata` (boolean): Remove GPS location, XMP, IPTC and comments from photos (originals untouched)
- `threads` (integer)
- `volumeSize` (string): Split into volumes of this size, e.g. "25m"

### `create_each` (~154 tokens)

Compress each item separately

Make one archive per top-level item of a folder (or per listed item), e.g. one zip per customer folder. Defaults to dryRun=true.

Input parameters:

- `baseDir` (string, required): Folder whose items are archived one by one
- `dryRun` (boolean)
- `excludeHeavyDirs` (boolean)
- `excludeSecrets` (boolean)
- `format` (string)
- `include` (array): Items (relative to baseDir); default every non-hidden item
- `level` (integer): 0 = store, 5 = normal, 9 = ultra
- `outDir` (string, required): Where the archives are written
- `overwrite` (boolean)
- `password` (string)

### `add_to_archive` (~135 tokens)

Add files to an archive

Add files from a folder into an existing zip/7z/tar archive (same paths are replaced). Secrets and generated folders are left out by default. Defaults to dryRun=true, which lists what would be added and replaced.

Input parameters:

- `baseDir` (string, required): Folder the added paths are relative to
- `dryRun` (boolean)
- `excludeHeavyDirs` (boolean)
- `excludeSecrets` (boolean)
- `include` (array): Paths relative to baseDir; default everything
- `password` (string): Archive password, if encrypted
- `path` (string, required): Absolute path to an archive file

### `delete_from_archive` (~91 tokens)

Delete entries from an archive

Remove files or folders from a zip/7z/tar archive in place. Changes the archive permanently: run with dryRun=true first (the default) and confirm with the user.

Input parameters:

- `dryRun` (boolean)
- `entries` (array, required): Entry paths or folder prefixes
- `password` (string): Archive password, if encrypted
- `path` (string, required): Absolute path to an archive file

### `rename_in_archive` (~92 tokens)

Rename entries in an archive

Rename or move files and folders inside a zip/7z/tar archive without re-compressing. Unsafe new names (../, absolute, reserved) and collisions are refused. Defaults to dryRun=true.

Input parameters:

- `dryRun` (boolean)
- `password` (string): Archive password, if encrypted
- `path` (string, required): Absolute path to an archive file
- `renames` (array, required)

### `rename_by_rules` (~188 tokens)

Bulk rename by rules

Rename many files inside a zip/7z/tar at once by rules: find/replace (text or regex), replace spaces, lowercase/uppercase, add a prefix/suffix, limited to selected globs. Unsafe results and collisions are skipped. Defaults to dryRun=true (shows the plan).

Input parameters:

- `case` (string)
- `dryRun` (boolean)
- `find` (string)
- `ignoreCase` (boolean)
- `password` (string): Archive password, if encrypted
- `path` (string, required): Absolute path to an archive file
- `prefix` (string)
- `regex` (boolean)
- `replace` (string)
- `spaces` (string): Replace spaces with this (e.g. "_")
- `suffix` (string)
- `targets` (array): Only entries matching these globs (e.g. ["*.jpg"])

### `convert_archive` (~184 tokens)

Convert archive format

Re-pack an archive into another format (e.g. rar → zip for sharing, zip → 7z for size, anything → tar.gz for Linux). Goes through a safe extraction, so unsafe entries are dropped. Reports the size before and after. Defaults to dryRun=true.

Input parameters:

- `dryRun` (boolean)
- `encryptNames` (boolean)
- `format` (string): Default: from the output file extension
- `level` (integer): 0 = store, 5 = normal, 9 = ultra
- `newPassword` (string): Encrypt the new archive (the source password is NOT carried over otherwise)
- `output` (string, required): Output path; the extension picks the format
- `overwrite` (boolean)
- `password` (string): Archive password, if encrypted
- `path` (string, required): Absolute path to an archive file

### `optimize_archive` (~99 tokens)

Make an archive smaller

Re-pack any archive as the smallest practical 7z (LZMA2, ultra, solid), keeping its password. Writes a new file next to it; the original is untouched. Defaults to dryRun=true.

Input parameters:

- `dryRun` (boolean)
- `output` (string)
- `overwrite` (boolean)
- `password` (string): Archive password, if encrypted
- `path` (string, required): Absolute path to an archive file

### `create_patch` (~110 tokens)

Create a delta update patch

Compare two versions of an archive and build a small patch that contains only the added and changed files (plus a manifest of removals). Ship the patch instead of the whole new archive. Defaults to dryRun=true.

Input parameters:

- `dryRun` (boolean)
- `newArchive` (string, required): Absolute path to an archive file
- `oldArchive` (string, required): Absolute path to an archive file
- `output` (string, required): Patch file to write
- `password` (string): Archive password, if encrypted

### `apply_patch` (~112 tokens)

Apply a delta update patch

Apply a Pullzip patch to a base archive to produce the updated archive. Refuses if the base is the wrong version (hash mismatch) unless force is set; verifies the result contents. Defaults to dryRun=true.

Input parameters:

- `base` (string, required): Absolute path to an archive file
- `dryRun` (boolean)
- `force` (boolean)
- `output` (string, required)
- `password` (string): Archive password, if encrypted
- `patch` (string, required): Absolute path to an archive file

### `merge_archives` (~147 tokens)

Merge archives into one

Combine several archives into a single new archive; by default each source keeps its own folder (name clashes are renamed). Goes through a safe extraction, so unsafe entries are dropped. Defaults to dryRun=true.

Input parameters:

- `dryRun` (boolean)
- `flatten` (boolean): Merge at the top level instead of one folder per archive
- `format` (string): Default: from the output file extension
- `inputs` (array, required)
- `level` (integer): 0 = store, 5 = normal, 9 = ultra
- `output` (string, required): Output archive path
- `overwrite` (boolean)
- `password` (string): Archive password, if encrypted

### `sync_archive` (~133 tokens)

Sync an archive with a folder

Refresh an existing zip/7z/tar so it matches a folder: add new and changed files, and (with del=true) drop entries whose files were deleted. Only changed files are re-compressed. Defaults to dryRun=true.

Input parameters:

- `baseDir` (string, required): The folder to match
- `del` (boolean): Also remove entries whose files no longer exist
- `dryRun` (boolean)
- `excludeSecrets` (boolean)
- `password` (string): Archive password, if encrypted
- `path` (string, required): Absolute path to an archive file
- `respectGitignore` (boolean)

### `redact_archive` (~130 tokens)

Mask secrets inside an archive

Write a copy of an archive with keys, tokens, passwords, resident numbers, phone numbers, cards and e-mails masked inside its text files. Binary files are copied unchanged; the original is untouched. Defaults to dryRun=true.

Input parameters:

- `dryRun` (boolean)
- `format` (string): Default: from the output file extension
- `newPassword` (string)
- `output` (string): Default "<name>-redacted.zip"
- `overwrite` (boolean)
- `password` (string): Archive password, if encrypted
- `path` (string, required): Absolute path to an archive file

### `pack_in_parts` (~123 tokens)

Pack into size-limited archives

Pack a folder into several independent archives, each at most maxMb — unlike split volumes, every part opens on its own (good for e-mail or upload limits). Files bigger than the limit are reported. Defaults to dryRun=true.

Input parameters:

- `baseDir` (string, required)
- `dryRun` (boolean)
- `format` (string)
- `level` (integer): 0 = store, 5 = normal, 9 = ultra
- `maxMb` (integer)
- `outDir` (string, required)
- `password` (string)

### `extract_nested` (~112 tokens)

Extract nested archives

Extract an archive and every archive inside it (zip in zip in 7z ...) level by level with the same safety rules, into one folder tree; inner archives are removed after they are unpacked unless keepInner=true.

Input parameters:

- `dest` (string, required): Destination folder
- `keepInner` (boolean)
- `maxDepth` (integer)
- `password` (string): Archive password, if encrypted
- `path` (string, required): Absolute path to an archive file
- `skipExecutables` (boolean)

### `organize_photos` (~103 tokens)

Sort photos by date taken

Copy (or move) photos and videos from a folder or an archive into YYYY/YYYY-MM folders by the date they were taken (EXIF), skipping exact duplicates. Defaults to dryRun=true.

Input parameters:

- `dest` (string, required): Album folder
- `dryRun` (boolean)
- `move` (boolean): Move instead of copy (folders only)
- `password` (string): Archive password, if encrypted
- `source` (string, required): Folder or archive with photos

### `archive_health` (~91 tokens)

Archive health check

Test every archive in a folder and compare with the previous check (ledger file .archiveflow-health.json in that folder): reports broken archives and silent corruption (bytes changed although the file was never modified), plus new, modified and missing ones.

Input parameters:

- `dir` (string, required): Folder of archives (backups, archive storage)
- `password` (string): Archive password, if encrypted
- `recursive` (boolean)

### `snapshot_folder` (~114 tokens)

Snapshot a folder (version backup)

Save a new version of a folder into a snapshot folder: only files that changed since the last snapshot are stored (as a normal 7z), but every snapshot can be restored in full. Secrets are left out unless includeSecrets.

Input parameters:

- `dir` (string, required): Folder to back up
- `includeSecrets` (boolean)
- `note` (string)
- `password` (string)
- `repo` (string, required): Snapshot folder (keep it outside the backed-up folder)
- `respectGitignore` (boolean)

### `restore_snapshot` (~92 tokens)

Restore a snapshot

Restore a folder exactly as it was at a snapshot (default: the latest) into a destination folder; existing files there with the same names are replaced, so prefer an empty folder.

Input parameters:

- `dest` (string, required)
- `id` (string): Snapshot id from list_snapshots
- `only` (array): Restore only these files or folders
- `password` (string)
- `repo` (string, required)

### `seal_archive` (~101 tokens)

Seal an archive

Write a signed seal next to an archive (<archive>.afseal.json) that later proves the archive and every file in it are unchanged, and that this user sealed it (Ed25519 key kept on this computer). Useful for contracts, evidence, deliveries and backups.

Input parameters:

- `note` (string)
- `overwrite` (boolean)
- `password` (string): Archive password, if encrypted
- `path` (string, required): Absolute path to an archive file

### `quarantine_file` (~64 tokens)

Quarantine a file

Move a suspicious file into the Pullzip quarantine folder (renamed so it cannot be opened by double-click), recording why, its hash, security findings and download address. Can be restored later.

Input parameters:

- `path` (string, required): File to quarantine
- `reason` (string)

### `restore_quarantined` (~58 tokens)

Restore from quarantine

Move a quarantined file back to where it was (or to another folder). Only do this when the user is sure the file is safe.

Input parameters:

- `id` (string, required): Id from list_quarantine
- `to` (string)

### `strip_photo_metadata` (~93 tokens)

Remove photo location

Remove GPS location, XMP, IPTC and comments from JPEG/PNG photos without re-encoding them (orientation and colors stay). Writes cleaned copies to outDir, or changes the originals only with inPlace=true. Defaults to dryRun=true.

Input parameters:

- `dryRun` (boolean)
- `inPlace` (boolean)
- `outDir` (string)
- `paths` (array, required): Photos or folders

### `prepare_for_sharing` (~171 tokens)

Pack files to send

One step to send files safely: leaves out secrets (.env, keys), removes photo locations, adds a generated AES-256 password, splits into mail-sized parts, and writes the message to send (password to be sent separately). Defaults to dryRun=true.

Input parameters:

- `baseDir` (string, required): Folder to send
- `dryRun` (boolean)
- `format` (string)
- `include` (array)
- `lang` (string)
- `limitMb` (integer): Mail attachment limit in MB
- `name` (string)
- `outDir` (string, required): Where the archive is written
- `overwrite` (boolean)
- `password` (string|boolean): true = generate, false = none, or a password
- `stripPhotoMetadata` (boolean)

### `sanitize_archive` (~132 tokens)

Make a clean copy

Write a copy of an archive without programs, scripts, shortcuts, macro documents, disguised files, risky Office files and dangerous nested archives (content-checked). The original is untouched. Defaults to dryRun=true, which lists what would be removed.

Input parameters:

- `dryRun` (boolean)
- `format` (string): Default: from the output file extension
- `newPassword` (string)
- `output` (string): Default "<name>-clean.zip"
- `overwrite` (boolean)
- `password` (string): Archive password, if encrypted
- `path` (string, required): Absolute path to an archive file

### `repair_archive` (~117 tokens)

Repair a damaged ZIP

Rebuild a ZIP that will not open (cut-off download, missing central directory, junk in front) by reading its file records one by one. Writes a new "<name>-repaired.zip"; the original is untouched. Reports recovered and lost files, and tests the result. Defaults to dryRun=true.

Input parameters:

- `dryRun` (boolean)
- `output` (string)
- `overwrite` (boolean)
- `password` (string): Archive password, if encrypted
- `path` (string, required): Absolute path to an archive file

### `check_update` (~70 tokens)

Check for a newer Pullzip

Compare this Pullzip with the latest published version and list what changed since (fetches https://pullzip.download/updates.json — nothing is sent). Set AF_OFFLINE=1 to disable.

Input parameters:

- `lang` (string): Language for the change notes, e.g. ko, ja, zh-CN

## Diagnostics

Captured diagnostic sections: Provenance. The full working is on the page: https://verifymcp.io/servers/work517-archiveflow/https-github-com-work517-archiveflow-releases-releases-download-v0-6-0-archivefl#diagnostics

## Score history

- 2026-09-20: 40
- 2026-09-19: 40
- 2026-09-18: 40
- 2026-09-17: 40
- 2026-09-16: 40

## Common questions

### What is the Pullzip MCP server?

Pullzip is an MCP server listed in the public MCP registry as io.github.work517/archiveflow. Inspect, search and safely extract zip/7z/rar/tar archives; repair garbled CJK file names. This page covers its MCPB bundle (https://github.com/work517/archiveflow-releases/releases/download/v0.6.0/archiveflow-0.6.0.mcpb).

### Is the Pullzip MCP server safe to use?

Pullzip scores 40 out of 100 on VerifyMCP. It declares no install or post-install scripts. 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 Pullzip MCP server expose?

Pullzip exposes 67 tools: inspect_archive, list_entries, search_archive, read_entry, scan_security, and 62 more. Their descriptions and schemas cost roughly 6,940 tokens of context every time the server is loaded.

### What licence is the Pullzip MCP server under?

Pullzip declares the Proprietary licence, which is not on the OSI-approved list. Read the terms before using it at work, and note this covers the source only, not the cost of any service it calls.

## Links

- Repository: https://github.com/work517/archiveflow-releases
- Changelog RSS feed: https://verifymcp.io/servers/work517-archiveflow/https-github-com-work517-archiveflow-releases-releases-download-v0-6-0-archivefl.xml
- Changelog JSON feed: https://verifymcp.io/servers/work517-archiveflow/https-github-com-work517-archiveflow-releases-releases-download-v0-6-0-archivefl.json
- HTML version of this page: https://verifymcp.io/servers/work517-archiveflow/https-github-com-work517-archiveflow-releases-releases-download-v0-6-0-archivefl