Skip to main content
Glama
819,312 tools. Updated 2026-11-22 04:18

"A tool for finding relevant files in a Git project based on questions" matching MCP tools:

  • Report a problem with the Fiskmås toolset so it can be fixed. Use it when a tool errored or misbehaved, you got stuck and can't proceed, or the instructions/skill were unclear. Do NOT use it for praise. kind=bug means it broke, kind=suggestion means it was unclear or could be better, kind=other is anything else that didn't work. Name the `tool` and, if relevant, the `project`. At most one call per session.
    ConnectorNo auth
  • Fetch the AI-maintained memory document for a project or workspace — the best single source for a handoff-style briefing. Sections include purpose, glossary, key people, activity digest, and routing signals, distilled across all meetings. Pass EXACTLY ONE of `project_id` (project memory) or `workspace_id` (workspace-level memory); get ids from `list_workspaces`. Returns the memory as rendered markdown plus `updated_at`. Start here for "give me a summary / bring me up to speed on project X" questions, then drill into `find_subjects`/`search_meeting_transcripts` for specifics.
    ConnectorOAuth
  • Upload a file from a public source URL into an ACC project folder. Runs the full four-step APS Data Management flow: top-folder discovery → storage object creation → OSS PUT of bytes → first-version item creation. When to use: The user wants to push a document/photo/model into ACC Docs — e.g. 'upload this site photo to the Tower project Photos folder' or an automation needs to archive an exported report into Project Files. When NOT to use: Do not use for files already in ACC; do not use for files behind auth-gated URLs (fetch step is an unauthenticated GET). For very large files (>100MB), prefer the chunked/signed-S3 upload flow, not this single-PUT implementation. APS scopes: data:read data:write data:create account:read. Rate limits: APS Data Management ~50 req/min per endpoint; OSS upload bandwidth typically 100 MB/min per app. This tool issues 3–5 APS calls per upload, so budget accordingly. Errors: 401 (APS token expired — refresh); 403 (user lacks folder write permission — ask account admin to grant 'Edit' on folder); 404 (project_id not found or folder_path does not match any top folder — verify 'b.' prefix, hub membership, and folder name); 422 (invalid file_name or conflicting version); 429 (rate limit — back off 60s); 5xx (ACC/OSS upstream — retry with jitter BUT be cautious: storage object may already be created so reuse, do not re-create). Also: if source file_url returns non-2xx, the tool throws before touching ACC. Side effects: Creates a storage object, uploads bytes, and creates a versioned item in the target folder. NOT idempotent — a retry may create a duplicate item with a new version. Surface the returned item_id to the user to avoid re-uploads.
    ConnectorNo auth
  • Archive a project (reversible shelve) — frees a project slot in-tool. Stops any in-flight machine, then flips the project to `archived`: it drops out of the per-tier project cap (freeing a slot for a new project) and the loop stops dispatching it, but the project + its history are kept and can be restored from the dashboard project page. Stopping a machine DESTROYS the running process state — restoring the project later cannot bring that execution back, so this is destructive despite being reversible. A replay on an already-archived project changes no row, but is not idempotent end to end. This is preferable to `delete_project` unless the project must be gone. Owner-scoped (an MCP key is owner-only); a project not in the workspace 404s.
    Connector
    Destructive
    No auth
  • Registers the project if it is new, attaches whatever source you give it, and deploys it using the application's Deployment workflow. Direct applications go to Production; Staged applications go to Development. Returns the live URL, or a deployment id to poll if the build is still running. **You do not decide whether this project needs git.** Send what you have and SpringRoll works it out: • a pushed git remote → pass `repositoryUrl` (and `ref` if not the default branch) • no remote, or uncommitted work → pass `archive`, a base64 tar+gzip of the source: tar --exclude=node_modules --exclude=.next --exclude=.git --exclude='.env*' \ -czf - . | base64 -w0 • both → SpringRoll builds from git, and falls back to your files if the ref cannot be resolved (an unpushed branch, typically) • neither, on an app that already exists → redeploys its current source Upload SOURCE, not build output: SpringRoll runs the build. node_modules, .next, dist, build, out, coverage and .log files are dropped automatically and reported. Every .env file and .git/ is REFUSED outright, naming the offending path: configuration belongs in SpringRoll, not in the bundle. Upload limits are about 3 MB compressed on the wire (a platform request-body cap, not a preference), 20 MB expanded, 2000 files, 512 KB per file; a project past them should pass `repositoryUrl` instead, which SpringRoll clones directly with no size limit. Sending the same files twice is free, because bundles are addressed by content. Direct to Production skips workflow approvals but keeps production safety checks. Staged applications continue to use explicit promotion and approvals.
    ConnectorNo auth
  • Raw file/git access at the indexed commit, for cloud agents with no clone; with a clone prefer your own Read/Grep/git. Ops: - read: content of filePath, whole file or slice startLine..endLine. ifHash (a prior read's hash) returns {unchanged:true}, no content. compact:true strips blank/comment-only lines. - list: files+subdirs at path. grep: ripgrep pattern (glob/pathPrefix). tree: layout from path. stat: size/lines/language/binary for filePath. blame: authorship for filePath. diff: fromSha..toSha. Keys: {op:"read",filePath:"src/a.ts"}, {op:"grep",pattern:"foo"}, {op:"list",path:"src"}. filePath is the file, path the directory. Gated by the Source Access add-on; else source_access_required.
    ConnectorNo auth

Matching MCP Servers

  • A
    license
    Not graded
    quality
    B
    maintenance
    Enables AI agents and MCP clients to call pay-per-use metered MCP endpoints, handle HTTP 402 payment challenges, top up compute packs, and enforce spend authorization with atomic reserve-commit-rollback accounting.
    MIT
  • A
    license
    Not graded
    quality
    B
    maintenance
    Enables AI agents to call tools through a security gateway that intercepts requests, enforces deterministic policy and risk checks, blocks or escalates high-risk actions for human approval, and keeps tool credentials and audit logs protected.
    1
    MIT

Matching MCP Connectors

  • Git AOAuth

    Many AI agents on one repo, every change lands on main. Read code, propose changes, review, read CI.

  • Indicative UK skip hire prices by town, council skip permit rules and skip size recommendations.

  • List the user's workspaces AND the projects inside each workspace — projects are returned nested, so this is also the tool for finding a `project_id` (there is no separate list_projects tool). Call it first whenever another tool needs `workspace_id` or `project_id` (`list_transcriptions` filters, `find_subjects`, `list_open_questions`, `search_meeting_transcripts`). Returns id, name, type (personal/team), your role, and per-project recording counts. Cheap — one small response.
    ConnectorOAuth
  • MACHINE TOOL — your mcp-proxy calls this on its own; an agent never needs to. It reports git worktrees on `rtsc-NN/<slug>` branches that exist on this machine and that no live claim covers, so Retasc can SEE work somebody started without claiming it (RTSC-962). The server never reads git; the local proxy does, and reports. Each reported issue gets a PROVISIONAL HOLD: it becomes visible on `get_issue` / `list_issues` as `hold`, and automatic dispatch (`next_issue` / `next_batch`) withholds it, exactly as it skips another human's lane. A hold is NOT a lease — it has no token, `heartbeat`/`checkpoint`/`done` do not accept it, `check_claim` reports it as not held, and it lapses 60 minutes after the last report. Nothing refuses an explicit `claim_issue`: a named claim from ANY session converts the hold into a real claim, which is how the agent that forgot to claim gets its work back. Ignores anything already claimed, terminal, `work:false`, or outside this key's project.
    ConnectorAPI key
  • Remove a project's S3 bucket: the app loses the bucket and every file in it now. It unsets the S3_* variables (the app restarts without them) and then deletes the bucket's access key. spawnpoint keeps the bucket and its files for 7 days, and a person who may delete the project (its owner; on a team, its builder or a team admin) can restore it from the project's Storage panel in the console; after that it is deleted for good. Even when the user asked to remove the bucket, first reply telling them the app loses the files, ask them to confirm, and stop; call with confirm: true only after they answer yes. Without confirm the call refuses and nothing happens. To replace a leaked key instead, use rotate_storage_key. A protected project refuses it: only its owner turns protection off, on the project's page in the console, so relay the refusal instead of looking for another way.
    Connector
    Destructive
    API key
  • Add a list of up to 50 tasks to an existing Onplana project in one call, at the project root or under a sprint / epic. Fits "add these tasks to my launch project" or a checklist pasted into the chat. Single transaction (all-or-nothing), in place of calling create_task N times; add_subtasks covers new tasks that are children of an existing task. THIS TOOL DOES NOT SCHEDULE. Tasks land with NO dates unless startDate and dueDate are set on each one, and there is no way to express durations or predecessors here at all. A schedule (phase durations, effort estimates, "task 5 depends on task 3", a critical path) sent through this tool arrives as a flat dateless list, and the Gantt, timeline and critical path are all empty. Use instantiate_plan instead, which takes estimatedDays per task and computes real start and due dates from them. It accepts a projectId, so it works on a project that already exists. Neither tool accepts predecessors: create the tasks first, then add each dependency with link_dependency. The result includes `url` for the project (and one per task). ALWAYS show the project link in your reply so the user can open what you just created.
    ConnectorOAuth
  • Performs semantic search across persistent long-term memory to retrieve grounded facts, relevant citations, and source documents matching a natural language question. Use this tool when answering questions about previously saved project specifications, codebase decisions, user preferences, or documents. Do NOT use for saving new facts (use icx_remember), do NOT use for raw keyword lookup (use icx_search_facts), and do NOT use for exact character-for-character verbatim quotes (use icx_quote_slot). Read-only operation with zero side effects. Requires X-License-Key authentication.
    ConnectorNo auth
  • Upload files straight from disk instead of pasting their bytes into a tool call: for images, audio, fonts, 3D models, and ANY file over ~50 KB (a tool call can't carry megabytes of base64). Give each file's hosted path and exact size in bytes; get back one URL per file. PUT each file to its URL with curl, from the game's folder: curl -sS -T <local file> "<url>" (Windows PowerShell: curl.exe). Each URL takes ONE PUT of exactly that many bytes and expires in 15 minutes, so upload right away. Then call publish_game with { path, uploadId } entries for these files (small text files can still go inline next to them), or deploy_room_logic with uploadId for a long logic file. An upload belongs to the game it was made for and is used up by the publish. Limits on this studio's plan: 100 files per call, 5 MB per game.
    ConnectorNo auth
  • Registers the project if it is new, attaches whatever source you give it, and deploys it using the application's Deployment workflow. Direct applications go to Production; Staged applications go to Development. Returns the live URL, or a deployment id to poll if the build is still running. **You do not decide whether this project needs git.** Send what you have and SpringRoll works it out: • a pushed git remote → pass `repositoryUrl` (and `ref` if not the default branch) • no remote, or uncommitted work → pass `archive`, a base64 tar+gzip of the source: tar --exclude=node_modules --exclude=.next --exclude=.git --exclude='.env*' \ -czf - . | base64 -w0 • both → SpringRoll builds from git, and falls back to your files if the ref cannot be resolved (an unpushed branch, typically) • neither, on an app that already exists → redeploys its current source Upload SOURCE, not build output: SpringRoll runs the build. node_modules, .next, dist, build, out, coverage and .log files are dropped automatically and reported. Every .env file and .git/ is REFUSED outright, naming the offending path: configuration belongs in SpringRoll, not in the bundle. Upload limits are about 3 MB compressed on the wire (a platform request-body cap, not a preference), 20 MB expanded, 2000 files, 512 KB per file; a project past them should pass `repositoryUrl` instead, which SpringRoll clones directly with no size limit. Sending the same files twice is free, because bundles are addressed by content. Direct to Production skips workflow approvals but keeps production safety checks. Staged applications continue to use explicit promotion and approvals.
    ConnectorNo auth
  • Create a project (a board of assignments) in the caller's company. The caller becomes its creator; members are added in the cabinet. Use when work needs a new board — not for a single task, which belongs on an existing project. Check erp_list_projects first: a project with the same name is reused, never created twice. When the person also names tasks for the new project («створи проєкт X і додай задачу Y, термін 10 днів»), pass them in 'assignments' — they are created in the same confirmation, right after the project. CONFIRMATION: this tool is PROPOSED, never performed directly. You get status='confirmation_required' with an action_id and a plan_token, and the write happens only after confirm_action.
    ConnectorOAuth
  • Write file changes to a project's git repo as one commit, without a git client. Use it in a client with no shell access, or when git cannot push from this machine: no SSH key that ``list_ssh_keys`` lists for the account, and no ``$XHOSTD_TOKEN`` in the environment. Never ask the user to paste a token. A commit stores code and deploys nothing; ``deploy`` is its own call. One commit carries any mix of three change kinds: * ``files``: whole content. It creates a file, replaces one, or deletes one (pass null). * ``edits``: anchored replacements inside a file that already exists. * ``patches``: anchored hunks, for several changes to one file in one payload. ``edits`` and ``patches`` carry only the changed region of a file, so a one-line fix in a 78 KB file sends the anchor and not the file. ``files`` carries the whole content. ``edits`` maps a path to a list of ``{"old_string": ..., "new_string": ..., "replace_all": false}``. ``old_string`` must occur EXACTLY ONCE in the file unless ``replace_all`` is true. If it occurs zero times or more than once, the whole commit fails and nothing is written — add surrounding lines until the anchor is unique. ``patches`` maps a path to hunks. A hunk header is ``@@``, or ``@@ anchor`` where the anchor is a line or unique substring copied from the file. Put the anchor on a line the hunk covers, or on the line directly above it: matching starts there and runs to the end of the file. Body lines start with a space (context), ``-`` (remove), or ``+`` (add). There are no line numbers and no line counts. Each hunk needs at least one context or ``-`` line to locate the change:: @@ export const VERSION -export const VERSION = "1.4.0" +export const VERSION = "1.5.0" Matching is byte-exact for both: no whitespace, indentation, or line-ending tolerance. Copy anchors from ``read_source_file`` output. Edits and hunks apply in order, each against the result of the previous one. A path belongs to exactly ONE of the three fields. The commit is all-or-nothing, so a failure never leaves the repo half-updated. Returns {sha}. Deploy it with deploy(project, environment, sha). A project with a connected source repository refuses this call: its code comes from that repository, and a push there reaches the project. A 503 commits nothing: another write holds the repo, or the project is under scheduled maintenance. Retry in a minute. Reference: https://docs.xhostd.com/mcp-tools#commit_files
    Connector
    Destructive
    OAuth
  • List one kind of item in one project by name and metadata; no secret value, password or file content comes back. It is the tool that lists every key of one environment. To find a key across projects, test exact names or compare environments use find_secret_keys; to read values use reveal_values or pull_env; for the project's fields use get_project. Items (arguments besides project and item): - environments: each with its key count; one outside this token's limits is marked restricted, with no count. - secrets (environment required): the keys. A plain (non-secret) entry carries its value; a key this token cannot open is flagged protected, sealed or restricted. - files (optional environment): newest first. Without environment: the project-level files plus those of every environment this token reaches. - logins: names, URLs and usernames. - deployment_urls: labels, URLs, primary, and the id manage_environments takes as url_id. - members: id, name and role, the id manage_members takes. secrets, files and logins are paged with cursor, limit and search; call again with nextCursor until it is null. Needs projects:read (logins:read for logins). Files and members also need full access: a partly shared project fails for them with a message.
    ConnectorOAuth
  • Built-in product help — a natural-language "how do I…" question about Fastio returns a grounded, product-aware answer (or a short clarifying question) in one call. EXPLAIN-ONLY / ADVISORY: it returns GUIDANCE TEXT and performs NO platform action (it will not create shares, move files, or change anything); the actions themselves are on the other tools. Answers are grounded in Fastio's own how-to knowledge AND phrased in terms of these MCP tools — they name the concrete `<tool> action="…"` calls, in place of guessed endpoints or exploratory calls. Q&A over the user's uploaded files (RAG) is the `ai_manage` tool; `how-to` answers questions about Fastio ITSELF. Costs no credits; needs only an authenticated user (no org needed). action='describe' gives the full action/param reference.
    ConnectorNo auth
  • Put one or more media files into your workspace media library (max 10, uploaded sequentially). This is step one of attaching media to a node - follow up with clipform_attach_node_media to place the returned media_asset_id on a node. When a public URL is provided, the media is fetched and stored automatically. The API picks where each asset is stored based on its size and type. Word-level captions from clipform_generate_tts enable per-word highlighting in the viewer once attached - pass the caption_ref it returned instead of hand-copying the captions array. PDFs (media_type document) are for consent agreements: they return a document descriptor, not a media_asset_id. Provide media via `items` (explicit type + URL), `files` (files attached by the host client), or both. At least one is required.
    ConnectorNo auth
  • Edit a manual logbook entry: only the fields you send change (empty notes clear them). It is the customer's own logbook: a typo or a wrong date is simply corrected. quest_id files an entry under a quest after the fact, and null files it back under the project alone. Tool events cannot be edited: they are derived from the canon and surface registries.
    ConnectorNo auth
  • Change the files of an EXISTING artifact and commit them, without git or a shell. Never creates a new artifact — the sessionId keeps pointing at the same one, and its playground URL does not change. If a Canvas draft exists, this refuses unless acknowledgeCanvasDraftRevision matches the draft you reviewed and the user explicitly chose to edit committed files. It does not edit, promote or discard the draft. All the changes you pass land as ONE commit: either every operation applies or none does. Read the files first with artifact-explore and pass the revision it returned as baseRevision; if someone else changed the artifact meanwhile the edit is rejected with REVISION_CONFLICT, which lists what changed so you can re-read those files and retry. Prefer op "str_replace" for edits to existing files (send the exact snippet), "write" to create a file or replace one wholesale, "delete", and "move" to rename. move does NOT rewrite imports — neither in the files that import the moved module, nor the relative imports INSIDE the moved file, which now resolve from its new folder, so read it first and add the str_replace operations that fix them. The live preview updates from the new commit immediately. To rename an artifact or change its visibility use artifact-update_metadata; for very large repositories or full git workflows (branches, history rewriting) use artifact-get_git_token.
    Connector
    Destructive
    OAuth
  • The way to release a game from a file on disk, with no tunnel and without exposing an unreleased game publicly. Returns three things at once: (1) `paczki_w_poczekalni`: packages already on the account that have not become a game yet, each with its `upload_id`; (2) `bilet`: a token valid for one hour ONLY for sending files, which you put in the `Authorization: Bearer` header (it opens no tool; you do not have it in your configuration, which is why you get it here); (3) a recipe: if you have a shell (curl), send the file with the ticket in two HTTP requests; if you do not, ask the owner to upload the ZIP in the studio at https://dev.klyo.pl/ (it lands in the waiting room, nothing is published) and call this tool again: the package will appear in `paczki_w_poczekalni`. Pass the returned `upload_id` to klyo_publish_game or klyo_update_game instead of `zip_url`. Do not save the ticket in project files. Examples: • How do I send a ZIP from my disk to klyo? • Publish this game, the file is on my computer • The owner uploaded a package in the studio, which one should I publish? • I don't want to expose the game publicly, how do I upload the package?
    ConnectorOAuth