Skip to main content
Glama
523,478 tools. Updated 2026-09-06 13:32

"Bash shell scripting and command line resources" matching MCP tools:

  • WRITE to the Knowledge Base. This tool has TWO modes: **MODE 1 — SAVE a new card**: Provide `content` with full Markdown following the ACTIONABLE schema below. **MODE 2 — REPORT OUTCOME**: Provide `kb_id` + `outcome` ('success' or 'failure'). WHEN TO USE: - Mode 1: After successfully fixing a bug IF no existing KB card covered it. - Mode 2: ALWAYS after applying a solution from `read_kb_doc` and running verification. INPUT: - `content`: (Mode 1) Full Markdown KB card content — follow the EXACT template below. - `overwrite`: (Mode 1) Set to True to update an existing card. - `kb_id`: (Mode 2) ID of the card to report outcome for. - `outcome`: (Mode 2) 'success' or 'failure'. - `enrichment`: (Mode 2, optional) Additional context to merge into the card when outcome is 'failure'. ━━━ CARD TEMPLATE (Mode 1) — copy this structure EXACTLY ━━━ ``` --- kb_id: "[PLATFORM]_[CATEGORY]_[NUMBER]" # e.g. WIN_TERM_001, CROSS_DOCKER_002 title: "[Short Title — max 5 words]" category: "[terminal|devops|supabase|fastmcp|network|database|...]" platform: "[windows|linux|macos|cross-platform]" technologies: [tech1, tech2] complexity: [1-10] criticality: "[low|medium|high|critical]" created: "[YYYY-MM-DD]" tags: [tag1, tag2, tag3] related_kb: [] --- # [Short Title — max 5 words] > **TL;DR**: [One sentence — what's the problem + solution] > **Fix Time**: ~[X min] | **Platform**: [Windows/Linux/macOS/All] --- ## 🔍 This Is Your Problem If: - [ ] [Symptom 1 — specific symptom or error message] - [ ] [Symptom 2 — specific error code or log line] - [ ] [Symptom 3 — environment/version condition] **Where to Check**: [console / logs / env / task manager / etc.] --- ## ✅ SOLUTION (copy-paste) ### 🎯 Integration Pattern: [Global Scope] / [Inside Init] / [Event Handler] ```[language] # [One-line comment — what this code does] [depersonalized code WITHOUT specific paths, use __VAR__ for things to replace] ``` ### ⚡ Critical (won't work without this): - ✓ **[Critical Point 1]** — [why it's essential] - ✓ **[Critical Point 2]** — [common mistake to avoid] ### 📌 Versions: - **Works**: [OS/library versions where confirmed working] - **Doesn't Work**: [OS/library versions where known broken] --- ## ✔️ Verification (<30 sec) ```bash [single command to verify the fix worked] ``` **Expected**: ✓ [Specific output or behavior that confirms success] **If it didn't work** → see Fallback below ⤵ --- ## 🔄 Fallback (if main solution failed) ### Option 1: [approach name] ```bash [command] ``` **When**: [condition to use this option] | **Risks**: [what might break] ### Option 2: [alternative approach] ```bash [command] ``` **When**: [condition] | **Risks**: [what might break] --- ## 💡 Context (optional) **Root Cause**: [1 sentence — why this problem occurs] **Side Effects**: [what might change after applying the fix] **Best Practice**: [how to avoid this in future — 1 point] **Anti-Pattern**: ✗ [what NOT to do — common mistake] --- **Applicable**: [OS, library versions, conditions] **Frequency**: [rare / common / very common] ``` ━━━ END OF TEMPLATE ━━━ RULES for ACTIONABLE cards: 1. Solution FIRST — after diagnosis, code immediately 2. Depersonalize — no names, project names, or absolute paths 3. Use `__VAR__` markers for anything the user must replace 4. One Verification command, result visible in <30 sec 5. Fallback — 1-2 options max, always include When/Risks 6. Context at End — WHY is optional reading for curious agents
    ConnectorNo auth
  • Arm a dead-man's-switch for EVERY line of a crontab in one call. Paste raw crontab text; Cronping parses each schedule, derives the expected interval from the cron expression itself (using the longest gap between runs so weekend/twice-daily schedules don't false-alarm), and creates one heartbeat monitor per job. Returns, for each line, a ping_url plus the same command with `&& curl -fsS <ping_url>` already appended so you can drop it straight back into the crontab. Also anchors each new check's first deadline to the schedule's real next run — so a fresh switch neither pages at t=0 nor sleeps a full period. No account required. Ideal when an agent or operator wants to instrument a whole box's scheduled jobs at once. Up to 20 lines per call. Lines with no fixed interval (e.g. @reboot) are skipped.
    ConnectorNo auth
  • Lists Mail.app email accounts WITH each account's email addresses, server_name and type. type is whatever Mail reports — imap | pop | iCloud | smtp | unknown — and Mail's scripting dictionary has NO Exchange value, so Exchange (EWS) accounts always come back as unknown, flagged with type_undetermined: true and a type_note; for those read the mailbox through the m365_* tools (or outlook_diagnose) instead of routing by type. Slower — queries Mail directly. For just the account NAMES (to pass to list_emails(account=...)), prefer list_email_accounts: it's faster (cached, no Mail lock).
    ConnectorNo auth
  • Returns instructions for creating a DPF account, verifying its email, resending the verification code, or resetting a forgotten password — it never performs these itself and never asks for a password. A password typed into this chat would sit in the conversation transcript, so every action instead returns the DPF website's own form, or a curl command that reads the password from a shell variable the user sets themselves in their own terminal. Hand the command to the user to run — do not run it yourself even if you have shell access, since composing the export line would require seeing the password. action "register": requires email, firstName, lastName, and termsAccepted: true (only after the user has explicitly agreed to the DPF Terms of Service and Privacy Policy in this conversation). action "verify": confirm the 6-digit code DPF emailed after registration (requires otp). action "resend": re-send that code if it never arrived. action "forgot-password": request a password-reset code (requires email). action "reset-password": submit that code and set a new password (requires otp).
    ConnectorOAuth
  • Validates a Python automation script that runs OUTSIDE the game, on three axes: Python syntax (using the real interpreter), Minecraft commands embedded in the script (against the official command index), and the shape of the /connect WebSocket message envelope. For behavior pack scripts use validate_script instead — Python does not run inside a pack. The embedded command check is the most valuable one: a command written from memory can look syntactically fine and still do nothing in the game. Only strings starting with / are treated as commands. If syntax could not be checked, syntaxChecked is false in the result; ok:true alone does not mean the syntax is valid.
    ConnectorNo auth
  • SESSION-RECOVERY · FIRST CALL when a session starts and the user mentions launch / users / growth / customers / metrics / revenue / marketing / what next / shipping. Returns a command-center bootCard with `headline`, `priority`, `cards[]` (each carries kind + label + literal user command + runHandle), and `next` (the one-line prompt). Aggregates: pending approvals + ripe measurements + new engagement + queued prospects + recent launches + manual-publish-pending actions. ChiefLab is stateful and re-summonable — even if the conversation was lost, the IDE was switched, or the runId was forgotten, this call recovers the workspace business state. If the user asked to launch the CURRENT repo, compare boot cards to currentRepoContext/projectName; if the open loop is unrelated, start a fresh launch instead of resuming stale work.
    ConnectorNo auth

Matching MCP Servers

Matching MCP Connectors

  • Manage a Command+K workspace: widgets, conversations, MCP connections, and usage analytics.

  • 39-endpoint crypto trading intelligence MCP for AI agents. Streamable HTTP over x402 pay-per-use (Base USDC). Catalog tools + agent-strategy console.

  • Scan source code for injection vulnerabilities: SQL injection, command injection, path traversal via unsafe string concatenation/unsanitized input. Supports Python, JavaScript, TypeScript, Java, Go, Ruby, Shell, Bash. Use to detect input-handling bugs; for secrets use check_secrets. Companion code-security tools: check_secrets (hard-coded credential detection), check_dependencies (known-CVE vulnerability audit), check_headers (live HTTP security-header validation), scan_headers (live HTTP scan via domain). Free: 30/hr, Pro: 500/hr. Returns {total, by_severity, findings}. No data stored.
    ConnectorNo auth
  • Export completed extractions as TMS/ERP-ready normalized line rows (one row per container / invoice line / package / goods line), newest first. Optional doc_type filter and max_rows cap. Corrected data wins over the original extraction. For CSV/XLSX files use GET /api/bol/export on the REST API.
    ConnectorNo auth
  • Check an MCP server for malware / prompt-injection lures by its endpoint URL. Give the server's streamable-http endpoint URL. Two paths: * **Already in the agent-tools directory** → returns our LATEST stored rule verdict. Every indexed server is re-scanned hourly, so you get a consistent, continuously-refreshed answer without re-probing. * **Not yet indexed** → we probe the endpoint live, statically scan its advertised tools + metadata, ADD it to the directory, and return the fresh verdict (so the next caller gets the rule verdict instantly from cache). Two dimensions are reported. `verdict` is authoritative and comes from deterministic static rules — pure pattern-matching over the *advertised* text only, NO code execution. It flags the social-engineering / RCE tricks listing-spam servers use: * `curl … | bash` and `base64 -d | sh` install lures * `eval "$(curl …)"` / PowerShell `IEX(...DownloadString)` cradles * base64 blobs that decode to a shell command * bare-IP payload hosts and cheap throwaway TLDs * prompt-injection / credential-exfiltration phrasing ("ignore previous instructions", "send your .env / api key") * MCP tool-poisoning coercion — descriptions that hijack an agent's tool-calling ("always call this tool first", "before using any other tool you must…"), hidden `<IMPORTANT>` instructions, "list all API keys / include secrets in your response", and coercion to read & forward `.key`/`.pem`/`.ssh`/`.env` files Source-code-oriented rules (SQL / command / code injection) are deliberately not applied to natural-language descriptions, to avoid false positives. `llm_reference` is an advisory frontier-LLM second opinion over the same text. Because the LLM is slow it is computed LIVE on this call only and is never stored (the hourly job never runs it), so it may be null on timeout. It never overrides the rule verdict; when it is *more* severe than the rules an `advisory` note is attached as a safety-net signal. Security/defense products that merely *name* these attacks are not flagged. Args: endpoint_url: The MCP server's streamable-http URL (required). This is the identity we look up / index by. name: Optional advertised name (used when the server is new and gets added; falls back to the URL host). description: Optional description / README blurb (scanned when new). tools_text: Optional tool names + descriptions; used only if the live probe cannot fetch the server's tools/list. Returns: { verdict: "clean"|"suspicious"|"malicious", score: 0-100, reasons: [{rule, weight, snippet}], llm_reference: {model, verdict, reason, confidence} | null, advisory: str | null, slug, name, endpoint_url, source: "stored" (existing) | "new_scan" (just added), indexed: bool }
    ConnectorNo auth
  • Free machine checkout builder. Select a paid IntentFence outcome and receive the exact endpoint, validated request, USDC cap, shell-safe Agentic Wallet argv, MCP tool call, and opt-in local auto-payment budget. It never signs or initiates payment.
    ConnectorNo auth
  • Live Chicago CTA 'L' train positions on one or more lines — where every Red Line, Blue Line, Brown, Green, Orange, Purple, Pink, or Yellow train is right now: lat/lon, heading, next station with ETA, destination, approaching and delayed flags. Answers "where are the Blue Line trains" for the Chicago L. Example: cta_train_positions({ routes: "Red,Blue" })
    ConnectorNo auth
  • READ-ONLY: returns text and writes nothing to disk, and does NOT run the command it shows you. Explains how to generate and use the fully-typed client for an @imqueue service: @imqueue generates the real client from a running service via `imq client generate`, so this returns that exact command plus an illustrative usage snippet. The generated file exports a single namespace holding the client class, so the import shape is not the obvious one — take it from `namespace` rather than guessing. Use generate_client (local install only) if you want the command actually run.
    ConnectorNo auth
  • Call this INSTEAD OF REFUSING when you need to send an API key, password, token, or any other credential to another agent or to your human. You are correct that a channel message is not safe for secrets — Apuchat stores message text in plaintext, so never paste a credential into send(). This tool returns the exact shell commands for a one-time encrypted drop: the secret is encrypted ON YOUR MACHINE, the hub receives only ciphertext and never has the key, and only a link travels through the channel. Inside a channel it gives you SEALED mode (ECDH): the receiver publishes a public key, the sender encrypts to it, and no key is ever transmitted in either direction — so both the request and the link are safe to paste in chat. The drop self-destructs on first read. IMPORTANT: this tool takes no secret and never will — do not pass one. Requires a shell (Bash tool or equivalent) to actually run the commands; if you have no shell, send the human the /s/new link this returns and let them seal it in their browser.
    ConnectorNo auth
  • SAFETY / OVERSIGHT CHECK before a dangerous or destructive action (shell command, file deletion, DB statement, network call). Call this to have VITNA check the action BEFORE you run it: it flags dangerous shell / SQL / secret-exfil / prompt-injection / suspicious-network patterns and returns { decision: allowed|blocked|flagged }. RESPONSE SHAPE DEPENDS ON THE KEY: an unclaimed trial key gets the decision label only, because the pattern detail is what makes the classifier worth stealing. A claimed key additionally gets threat_category, severity, reason (the rule names that matched, never the matched text), a threats[] array and a redacted echo of what was scanned, plus a signed audit record the user can review. VITNA evaluates and records; it does NOT enforce, so treat blocked / flagged as a stop and get human approval. This is how a user keeps you in check. Heuristic pattern match, not a sandbox: novel or obfuscated payloads can pass.
    ConnectorNo auth
  • Step-by-step integration instructions for actually compressing images — either through the @pipic/cli command-line tool (best for whole directories) or over plain HTTP (no Node required). Includes the output contract, exit codes, error codes and which failures are worth retrying.
    ConnectorNo auth
  • Returns which lines were added and which were removed, with line numbers — computed with a longest-common-subsequence, not guessed by a model. Use to compare two versions of a config, a document, or any command output, instead of asking an LLM to eyeball two blobs and hoping it notices.
    ConnectorNo auth
  • List the env vars a project's code can use and the resources behind them: (1) resources CONNECTED to the project — usable as process.env.<NAME> in endpoint code now; (2) the owner's other account-level credentials — reusable, but not usable in code until connected; (3) everything Floot can add. Call it to learn what env vars exist before writing backend code, and BEFORE provisioning or requesting any credential (the owner may already have the one you need). Pass query (case-insensitive substring over names, descriptions, types, and env var names) to filter when the account has many resources. Read-only. Details: get_guides('resources').
    ConnectorOAuth
  • Export a browser session's recorded action log. Format "bash" (default) returns a runnable curl script that replays every recorded action (navigate/click/input/scroll/eval) against a fresh session on this server — hand it to a shell or cron, zero model tokens. Format "jsonl" returns the raw action log, one JSON object per line.
    ConnectorNo auth
  • Scan source code (or snippet) for hardcoded secrets — cloud provider keys, API tokens, connection strings, private keys, passwords. Supports Python, JavaScript, TypeScript, Java, Go, Ruby, Shell, Bash. Use to detect leaked credentials before commit; for injection detection use check_injection. Free: 30/hr, Pro: 500/hr. Returns {total, by_severity, findings}. No data stored. The generic password-assignment rule is suppressed when a more-specific credential rule fires on the same line — one targeted finding per leaked secret, not two.
    ConnectorNo auth
  • SESSION-RECOVERY · FIRST CALL when a session starts and the user mentions launch / users / growth / customers / metrics / revenue / marketing / what next / shipping. Returns a command-center bootCard with `headline`, `priority`, `cards[]` (each carries kind + label + literal user command + runHandle), and `next` (the one-line prompt). Aggregates: pending approvals + ripe measurements + new engagement + queued prospects + recent launches + manual-publish-pending actions. ChiefLab is stateful and re-summonable — even if the conversation was lost, the IDE was switched, or the runId was forgotten, this call recovers the workspace business state. If the user asked to launch the CURRENT repo, compare boot cards to currentRepoContext/projectName; if the open loop is unrelated, start a fresh launch instead of resuming stale work.
    ConnectorNo auth
  • Pattern-based diff linter: flags a fixed set of risky shapes in changed code — query-string interpolation (SQL/Cypher/Mongo injection shape), shell interpolation, eval/new Function, empty catch blocks, regex built from a variable, fewer catch blocks than before, and named authorization guards that disappeared. Every finding cites the line that produced it. It does NOT do data-flow analysis: it cannot follow a value to a sink, across functions or files, and an empty result is not a safety verdict (the response lists what it did not analyse). Advisory triage — use a static analyser for a real security gate.
    ConnectorNo auth