venira-mcp
Installed, started with no arguments, no environment and no input, and listed its tools. Run 2026-11-16.
Needs to start: nothing
Returns a result when called with no setup: 3 of 5 tools tried
Contacts while installing and starting: nothing
Its tool definitions changed since version 1.21.0. If you approved the earlier ones, read them again.
What it contacted
Nothing besides the npm registry it was installed from. Watched from outside its sandbox while it was installed and started with no input. Its tools may still contact things when called.
Starting it
npx -y -p venira-mcp@4.4.0 venira-mcp
Installing a package runs its code. Use a sandbox for anything you have not read.
Calling its tools
5 tools that take no input and look read-only were called once with nothing. 3 returned a result.
list_files | Returned a result under 0.1 s · 523 characters |
search | No usable answer tool reported an error: {"ok":false,"status":"failed","request_id":"593ec84426d457732505f16a","kind":"search","error":{"code":"invalid_request","message":"Searc |
health | Returned a result under 0.1 s · 2,791 characters |
trace_status | Returned a result under 0.1 s · 388 characters |
read_audit | No usable answer tool reported an error: {"ok":false,"status":"failed","request_id":"22118322a7927f2d8bfdafa0","kind":"read_audit","error":{"code":"audit_unavailable","message": |
During the calls it contacted nothing it had not already contacted.
Only tools whose names read like looking something up, with no required input, are tried, five at most. Tools that need input, and anything that sounds like it changes or sends something, are not called.
What its tools tell an agent
In the tool descriptions, nothing that talks about the user, other tools or private files, or uses hidden characters.
Found by simple pattern rules in each tool's description (up to 3,000 characters), quoted as written. Parameter descriptions are not scanned. A clean result is not a safety review.
Tools
list_files relative_path, include_ignored, limit, depth
List files and directories (depth 1-3, limit up to 200). include_ignored=1 also lists ignored folders.
Use when: you need the directory tree or want to confirm a path exists.
Avoid when: you know the file (read_file) or want what changed lately (recent_files).
Output: entries[] {relative_path, kind, size_bytes}, truncated.read_file relative_path, start_line, end_line, line_numbers, max_bytes, ranges
Read a text file, whole or by line range (start_line/end_line, 1-based; ranges[] for several disjoint ranges of one file). Use when: you need one file's content. When truncated, call again with start_line=next_start_line. Avoid when: you need 2+ files (read_batch) or only size/mtime (get_file_info). Output: text (as preview in compact mode; preview_truncated marks a cut), first_line, last_line, total_bytes, truncated, next_start_line (when truncated). sha256 hashes the whole file and is safe as expected_sha256; text_sha256 covers only the returned text. Missing path gives not_found.
get_file_info relative_path, missing_ok
Return kind, size and modification time of a path. `missing_ok=1` answers ok with `data.exists:false` for a missing path instead of `not_found` (works inside read_batch items too). Use when: you need to know whether a path exists or how big it is. Use missing_ok=1 to probe existence without failing the call or the batch. Avoid when: you need the content (read_file). Output: kind, size_bytes, modified_unix_seconds, exists when missing_ok=1. Missing path gives not_found (or ok with exists:false and missing_ok=1).
search query, queries, files_hint, kind, relative_path, glob, exclude_glob, regex, case_sensitive, whole_word, include_hidden, context_lines, count_only, limit, hybrid
Search by kind: file_name, directory_name, literal_content (regex=1 for regex) or definition (symbol declarations). `queries` instead ranks matching lines by several weighted patterns (must/weight).
Use when: you must locate code, strings or symbols before reading. Keep relative_path narrow: a scan stops at 50000 files.
Avoid when: you know the path (read_file), want a file's structure (outline_symbol), a symbol's usages (symbol_references) or an executable on PATH (shell_run: `where <name>`).
Output: hits[] {relative_path, line_number, snippet}, complete, total_match_lines, files_matched. With queries: hits also carry score/matched, plus total_files/total_hits. No match is ok with empty hits.recent_files relative_path, limit, depth, include_ignored
List recently modified files, newest first, plus session_edits (files you wrote in this session).
Use when: you start or resume a task, or finished a build, format or git step and want to see what changed. Feed the top paths into read_batch.
Avoid when: you need the full tree (list_files) or a content search (search).
Output: entries[] {relative_path, size_bytes, modified_ago_seconds}, session_edits, truncated.33 more tools
read_batch requests
Run up to 8 read-only ops in one call. operation is the short name (list_files|read_file|get_file_info|search) mapping to list_files|read_file|get_file_info|search; arguments hold exactly that tool's parameters.
Use when: you need 2+ reads or mixed read steps. Items run in order and one failing item does not stop the rest.
Avoid when: a single read (read_file) or any edit (edit_batch).
Output: responses[] each {ok, response | error}, total_bytes_returned.write_file relative_path, content, mode, create_dirs, expected_sha256, reason
Write a file. mode=create (fails if it exists), overwrite, or append. create_dirs=1 creates parent folders. Use when: you create a file, replace one entirely, or append. expected_sha256 refuses the write if the file changed since you read it. Avoid when: you change a few lines (edit_file). overwrite is immediate and not undoable: snapshot first when the file is not in git. Output: action (created|overwritten|appended), bytes_written, sha256_after. mode=create on an existing path gives conflict.
edit_file relative_path, old_text, new_text, replace_all, edits, expected_sha256, reason
Replace exact text: old_text to new_text, or edits[] for several replacements in one file (edits[] wins). Use when: you make a targeted change. old_text must match exactly once unless replace_all=1. Pass expected_sha256 (read_file's sha256 or your last sha256_after) to refuse stale content and get a verified re-read. Avoid when: you rewrite the whole file (write_file) or change several files at once (edit_batch). Output: replacements, sha256_before, sha256_after, verified (when expected_sha256 is given). Failures leave the file unchanged: old_text_not_found (data.mismatch locates the first difference, data.context shows the nearby lines) and old_text_ambiguous (lists each match with context).
edit_batch edits
Apply edits across one or more files all-or-nothing. Each item takes edit_file arguments (relative_path, old_text, new_text, ...). The first failure rolls back every touched file from an automatic snapshot and skips the rest.
Use when: a change spans several files or sections and must land completely or not at all.
Avoid when: you make one edit (edit_file).
Output: success: per-edit {relative_path, replacements, sha256_after}. Failure: ok=false, error batch_failed, data {executed, skipped, rollback_succeeded, snapshot_id}.delete_path relative_path, recursive, reason
Delete a file or directory (recursive=1 is required for directories). Not undoable. Use when: you remove files or folders. Take a snapshot first when they are not in git. Avoid when: the target is uncertain (check with get_file_info or list_files). Output: entries_deleted, bytes_deleted. Missing path gives not_found.
move_path from, to, overwrite, create_dirs, reason
Move or rename a file or directory inside the workspace. overwrite=1 replaces an existing file, never a directory; create_dirs (default 1) makes missing parents of `to`. Use when: you rename or relocate files or folders. Not undoable: take a snapshot first when they are not in git. Avoid when: you duplicate (copy_path) or remove (delete_path). Output: from, to, kind, overwritten, entries, bytes. Missing source gives not_found, an existing target without overwrite gives conflict.
copy_path from, to, recursive, overwrite, create_dirs, reason
Copy a file, or a directory with recursive=1, inside the workspace. overwrite=1 replaces an existing file; symbolic links and protected files inside a directory are skipped. Use when: you duplicate a file or folder, for example to start from a template. Avoid when: you move or rename (move_path). Output: from, to, kind, overwritten, entries, bytes, skipped_symlinks/skipped_protected when any. Missing source gives not_found, an existing target without overwrite gives conflict.
apply_patch patch, dry_run, expected_sha256, reason
Apply a unified diff (git apply compatible) to one or more files, all-or-nothing. Every file is validated in memory before anything is written; a failing hunk rolls every file back from an automatic checkpoint, like edit_batch. dry_run=1 validates and reports without writing.
Use when: a change arrives as a diff (git diff, a patch file, another tool's output) and must land completely or not at all — files created, modified, deleted or renamed.
Avoid when: you have no diff (edit_file/edit_batch) or only need a new file (write_file). Not for directories or symbolic links.
Output: dry_run: files[] {action, relative_path, hunks, bytes} plus added/modified/deleted/renamed counts; nothing is written. success: same list plus sha256_after per file. Failure: nothing is changed; data carries rollback_succeeded and, for a mismatching hunk, nearest_context lines for the file and hunk that failed.shell_run shell, command, relative_cwd, background, secret_env, timeout_s, approval_id, approval_wait_s, dry_run, retry_failed, override, reason
Run a shell command in the workspace (shell, relative_cwd, timeout_s). Default is background: returns run_id, poll shell_status. background=0 blocks until exit and returns stdout/stderr. Use when: you build, test, run git or install packages. background=0 for short commands you need now. Avoid when: you read or edit files (file tools) or run a tiny JS calculation (execute_js). Output: run_id, kill_key, running, exit_code, timed_out, stdout/stderr (background=0) or stdout_tail/stderr_tail. ok=true only means the call ran; status (completed|failed|running|cancelled) and command_status describe the command. shell_path/shell_kind name the binary that ran it (on Windows bash may be the WSL launcher). approval_required: ask the user to approve, then retry once with approval_id. repeated_failure: the identical invocation already failed; read data.previous.stderr_tail, then change the command or pass retry_failed=1.
shell_status run_id, wait_seconds
Return the state and output tail of a shell run. wait_seconds (0-300) waits up to that long for it to finish. Use when: after a background shell_run: poll until running=false, then read exit_code. Avoid when: you have no run_id yet. Output: running, exit_code, stdout_tail, stderr_tail. Unknown run_id gives not_found (run ids only live for this session).
shell_cancel run_id, kill_key
Kill a running command and its child processes. Needs run_id and kill_key from shell_run. Use when: a command hangs or its result is no longer needed. Avoid when: the run already finished (shell_status). Output: accepted, cleanup_complete.
create relative_path, create_dirs, reason
Create a directory; missing parents are created unless create_dirs=0.
Use when: you need an empty directory. For a file use write_file, which also creates parent folders.
Avoid when: you edit existing content (edit_file).
Output: directory_created {relative_path, created, parents_created}.health include_audit, sections
Server diagnostics: version, workspace, security posture and warnings, caches, queue, running shells, latency, snapshot store, audit status. Use when: you debug slowness or errors, or want the security warnings before risky work. include_audit=0 skips the audit query. Avoid when: normal file work. Output: One key per report section (see sections); with sections set, also sections_requested and sections_unknown.
cache_clear type
Clear in-process caches (all, read, info, list, search, recent, negative, graph, shell). Use when: reads look stale because a tool changed files outside Venira. Avoid when: normal flow: writes already invalidate caches. Output: cleared entry counts per cache.
trace_status limit
Show recent traced tool calls (tracing is always on). Use when: you want to see what ran recently without opening the log file. Avoid when: tracing is off (the buffer is empty). Output: enabled, file, buffered, recent[] (newest first, timestamp_ms is epoch milliseconds).
memory action, content
Read or overwrite this workspace's handoff note at <workspace>/.venira/memory.md (action=read|write; write replaces it all, max 6000 bytes). Use when: a task starts or resumes (read, after recent_files); before you finish or run out of context (write: goal, decisions, files touched, next steps). Avoid when: lasting docs (write_file) or history (git_log). Plain text on disk: no secrets. Output: read: exists, content, bytes, updated_at_ms. write: replaced, previous_bytes, bytes, updated_at_ms. Over the cap or empty content: invalid_request, old note kept.
read_audit session_id, operation, outcome, request_id, limit, since_unix, verify
Read recent audit-log rows, newest first: what each job was asked and returned. Filter by session_id, operation, outcome, request_id, since_unix (seconds); verify=1 checks the hash chain.
Use when: you review what ran and how it ended, or look one job up by request_id.
Avoid when: you want live metrics (health).
Output: rows[] {session_id, operation, outcome, reason_code, reason, args_hash, command, request_id, started_at_ms, completed_at_ms, elapsed_ms, args_summary, result_summary, result_bytes}, count, truncated, chain_ok (verify=1). Output mode full adds redacted args and result per row; bulk text is kept as its length only. Timestamps are epoch milliseconds (since_unix filters in seconds). args_hash identifies the call, command is the redacted command line.switch_workspace root, reason
Re-root the workspace to another directory at runtime. Follows VENIRA_SECURITY_PROFILE: trusted/off (or VENIRA_UNRESTRICTED=1) switch anywhere existing; strict/balanced only inside VENIRA_WORKSPACE_ROOTS (unset = spawn only). Use when: the client spawned the server once (e.g. Claude Desktop) and the user changed to a different project folder; switch instead of restarting the client. Avoid when: one-shot tasks in the spawn directory, or under strict/balanced without VENIRA_WORKSPACE_ROOTS (the call is refused). Output: workspace_root (the new root), allowed_roots. All subsequent path guards and caches operate on the new root.
shell_cancel_session
Kill every shell run started in this session. Use when: you tear down a stuck session with several running commands. Avoid when: only one run must stop (shell_cancel). Output: cancelled_run_ids[], count.
outline_symbol relative_path, language, include_functions, include_classes, max_symbols
List a source file's top-level symbols (functions, classes, types, interfaces) with line numbers.
Use when: you want a file's structure before reading or refactoring it.
Avoid when: you need usages (symbol_references), a text search (search) or the text itself (read_file).
Output: total_symbols, symbols[] {name, kind, line, signature}.diff_files relative_path_a, relative_path_b, context_lines, max_lines
Unified diff between two workspace files. Use when: you compare two versions of a file, such as a backup and the current one. Avoid when: binary files, or git history (run git with shell_run). Output: lines_added, lines_removed, unified_diff, truncated.
symbol_references symbol_name, scope, relative_path, limit, max_references
Find occurrences of a symbol name. scope=file needs relative_path (one file); scope=workspace (default) searches all files.
Use when: you check where a symbol is used before renaming or changing it.
Avoid when: you only need its declaration (outline_symbol) or arbitrary text (search).
Output: count (matches found), returned (how many came back), omitted (cut by the cap), scan_limit (workspace only), references[] {relative_path, line_number, context}.dependency_graph kind, format, relative_path, depth, include_external, include_tests, languages, max_nodes, max_edges
Build the import and reference graph for TypeScript/JavaScript, Python, Rust, Go, Java and Kotlin. format: json, dot or mermaid.
Use when: you want module structure or what a subtree depends on. Narrow with relative_path, depth, languages.
Avoid when: you need usages of one symbol (symbol_references) or the impact of an edit (change_impact).
Output: nodes[], edges[] {from, to, type, confidence}, external[] (top 50), unresolved[] (top 10), stats {externals, unresolved_imports}, limited, truncated. dot and mermaid return data.graph.change_impact files, symbols, direction, depth, include_tests, max_nodes, min_confidence, format
List the files and symbols affected by changing given files or symbols (direction: dependents, dependencies or both). At least one of files/symbols; a symbol seed takes {name, relative_path} (file is an alias).
Use when: you are about to rename or change something and need which files to read and which tests to run.
Avoid when: you want the whole graph (dependency_graph).
Output: affected[] {id, distance, path, confidence}, summary {affected_files, affected_symbols, tests_affected}, unresolved[] (the seeds that did not resolve: symbol, reason, next_step), stats {unresolved_imports, min_confidence, filtered_possible}. By default only exact/likely edges are traversed; pass min_confidence="possible" to follow name-matching guesses.snapshot action, id, label, paths, exclude, respect_default_excludes, max_files, max_total_bytes, dry_run, verify, delete_extra, limit, reason
Checkpoint and roll back workspace files. action: create (label, paths) | list | restore (id) | delete (id) | mirror (copy to VENIRA_SNAPSHOT_MIRROR_DIR). Use when: before multi-file refactors or overwriting/deleting files git does not hold. Keep paths narrow and check file_count and skipped. Roll back with restore dry_run=1, then restore with verify=1. Avoid when: tiny single-file edits or states git already holds. Output: create: id, file_count, total_bytes, truncated, skipped[]. restore: restored[], deleted_count, skipped[].
git_status paths, reason
Parsed local git status: branch, ahead/behind vs upstream, and every changed file with staged/unstaged/untracked state and staged/worktree status letters.
Use when: you need the current repo state in a parseable form (before committing, stashing or opening a PR).
Avoid when: you only need the raw command (shell_run) or a remote host’s CI status (ci_status).
Output: ok, branch/detached, upstream (gone flag), ahead/behind, files[] {path, old_path?, staged, unstaged, untracked, unmerged, kind, status, index_status/worktree_status}, counts{}, clean.git_diff staged, paths, context_lines, include_patch, max_bytes, reason
Parsed git diff (staged or worktree): files + hunks (old_start/lines, new_start/lines, section). Patch text is opt-in via include_patch=1.
Use when: you need per-file hunk info for review/preview or a test, not free text.
Avoid when: you need a raw unified blob (use include_patch=1 or diff_files) or a PR diff (provider tools).
Output: files[] {old_path|null, new_path|null, action (added|modified|deleted|renamed), binary, hunks[] {old_start, old_lines, new_start, new_lines, section}}, counts{}, patch_bytes, patch/patch_truncated when include_patch=1.git_log ref, limit, paths, author, grep, blame, path, max_lines, reason
Local commit log, or per-line blame when blame=1 with path. Filters: ref, author, grep, paths.
Use when: you need recent commits or who last touched lines (blame).
Avoid when: you need tags/remote refs only (git branch --all) or a remote CI’s log (ci_logs).
Output: mode=log: commits[] {sha, short_sha, author, email, authored_at, committer, subject, body}, count. mode=blame: entries[] {line, commit, author, authored_at, summary}, lines.git_branch action, name, from, include_remote, force, reason
List local (and optionally remote-tracking) branches, or create/switch/delete one.
Use when: you need the current branch, want to branch off HEAD, switch branches, or prune a merged branch.
Avoid when: you need the worktree state (git_status) or a remote PR’s head branch (pr_list).
Output: list: current, branches[] {name, current, commit, upstream, track, remote}, branch_count. create/switch/delete: branch, commit/created/switched/deleted/force. Missing branch gives not_found; duplicate name gives conflict.git_commit message, paths, allow_empty, amend, reason
Commit changes. Without paths: commit whatever is staged (paths given to it are staged first with git add). Amend is opt-in. Use when: your edits are ready to be committed locally. Avoid when: nothing should be committed (git only stages when paths are given, or you already staged). Merge/rebase and push are not performed. Output: sha, short_sha, subject, files_changed, files, amend. No staged changes gives invalid_request (pass paths or stage first).
git_stash action, selector, paths, message, include_untracked, reason
Stash push/list/apply/pop/drop/show. Push stashes staged+unstaged tracked changes (add include_untracked=1 for untracked files).
Use when: you need to pause work to switch branches or commit selectively.
Avoid when: you need to stash and keep a copy (stash keeps one; use apply over pop) or drop permanently (prefer apply, then commit).
Output: push: pushed, message, selector, output. list: entries[] {selector, sha, subject}, count. apply/pop/drop: applied/dropped. show: files[], count.github_connect action, replace_existing, pending_id
Connect GitHub with Device Flow. action=start returns verification_uri and user_code: show them to the user, then action=poll with pending_id after they authorize. Tokens go to the encrypted vault and are never returned. Use when: the user wants to connect or replace the GitHub credential without pasting a token. Avoid when: you only need public read access, or a token is already configured. Output: start: verification_uri, user_code, pending_id, expiry. poll: pending | denied | expired | connected.
secret action, name, value, value_env, expires_in_days, expires_at, reveal, reason
Store and inspect tokens without exposing them (AES-256-GCM at rest). action: set | get (metadata only) | list | delete. Inject into commands with shell_run secret_env=[NAME]; the GitHub tools read GITHUB_TOKEN on their own. Use when: you save a non-GitHub token, check expiry or rotation, or remove one. Prefer value_env over value so the secret never appears in chat. Avoid when: the value is plain config (use .env or the config file). reveal=1 prints plaintext and needs VENIRA_SHELL_MODE=permissive or off. Output: set: name, length, expires_at, days_left. get and list: metadata only.
Descriptions are the package's own words, cut at 3,000 characters. Treat them as data.
Install facts
| License | AGPL-3.0-only |
|---|---|
| Needs | node >=20.0.0 |
| Source | github.com/N0moreher0/Venira-mcp |
| Install scripts | better-sqlite3, keytar declare them. This runner does not run them. |
| Tarball | sha512-octJitcRlfdwkUuyzi+4HOT4P5DZiN/LM314VX3NzcuAUqu4ykCJikB0akbK/9I6i83L1RdBJP4c7i4cvzYP2g== |
Versions reported
| Version | Run | Result | Tools |
|---|---|---|---|
| 4.4.0 | 2026-11-16 | Starts with no setup | 38 |
| 1.21.0 | 2026-11-12 | Starts with no setup | 32 |
Check this report yourself
This site did not write the report. A public job on a GitHub-hosted machine did: the run, from this commit of the open-source runner. GitHub signed a token that names that job and the hash of the report, so any edit since would show.
Report as JSONExact text and tokenHow to verify it
Show it on your README
[](https://bragproof.smaverk.com/r/venira-mcp)
New version out? Ask for a fresh report.