Skip to main content
Glama
682,084 tools. Updated 2026-10-20 17:31

"Reading terminal outputs from a Next.js dev server while developing in Cursor" matching MCP tools:

  • Re-read a webhook subscription's events in order from a cursor — answers 'my endpoint was down, what did I miss?'. Every delivery carries an X-PropLine-Sequence header, a counter monotonic WITHIN one subscription; pass the highest one the user processed as since_seq. Do NOT use the delivery id as the cursor: that id is global across all subscriptions, so gaps in it are other customers' traffic and mean nothing. Events come back OLDEST FIRST (the opposite of propline_get_webhook_deliveries, which is a newest-first debugging log). Page by passing next_seq back as since_seq while has_more is true. ALWAYS check `truncated`: true means events after the cursor already aged out of retention (2 days, max 5,000 deliveries per subscription) and are unrecoverable — tell the user to resync from the REST endpoints rather than reporting them caught up. latest_seq is not subject to retention, so latest_seq - next_seq is an honest 'how far behind' even when the rows are gone. Sequence numbers always increase and never repeat but are NOT guaranteed to be dense — a skipped number is normal and is not evidence of loss.
    ConnectorNo auth
  • Everything created, updated or deleted since a cursor (from the workspace digest/map or a previous call) or an ISO time — pages, databases, rows and deletions, oldest first. Omit both to bootstrap. Always keep nextCursor for the next call: this is how to catch up instead of re-reading the tree. An entry stamped in the cursor's own second may appear once more — dedupe by id.
    ConnectorOAuth
  • Attaches an EXISTING block volume to a running instance as an extra disk. This is how you finish a RESTORE after a VM is gone: restore_backup (volumeName) rebuilds the data into a new volume, then attach_volume puts that volume on a replacement instance - then SSH in (get_ssh_command) and mount it (`lsblk` to find it, usually /dev/vdb, then `mount /dev/vdb /mnt/...`). The volume must be 'available' (not already in-use - detach_volume it first) and in the same project. Attaching does NOT mount or boot from it: the instance keeps booting from its own root disk, the volume shows up as an extra block device. Poll list_volumes until status is 'in-use'.
    ConnectorNo auth
  • Get the state and output of an extract run (extract group) — resume a status: "running" run or inspect a failed one. wait: true blocks until terminal or wait-budget expiry. While status is "running", call again with wait: true (same workspaceId and environment) until it is terminal; never re-submit the document. On UNAUTHORIZED or NOT_FOUND, re-call get_me for the granted targets. Output shape is documented at https://docs.extend.ai/extraction/response-format.md (get_documentation).
    ConnectorOAuth
  • Get the aggregate status of a split batch (split group) submitted by run_split_batch. wait: true polls until terminal. Statuses: PENDING, PROCESSING, PROCESSED, FAILED, CANCELLED. While non-terminal, call again with wait: true; do not re-submit the batch. Individual results: list_split_runs filtered by batchId (status: "FAILED" for per-run failure reasons). Batch semantics: https://docs.extend.ai/general/batch-processing.md (get_documentation).
    ConnectorOAuth
  • Get the state and output of an edit run (edit group) — resume a status: "running" run or inspect a failed one. wait: true blocks until terminal or wait-budget expiry. Edit runs have no list endpoint — keep the run ID. While status is "running", call again with wait: true (same workspaceId and environment) until it is terminal; never re-submit the document. On UNAUTHORIZED or NOT_FOUND, re-call get_me for the granted targets. output.editedFile.presignedUrl expires in ~15 minutes (re-fetch with get_file). Output shape is documented at https://docs.extend.ai/editing/response-format.md (get_documentation).
    ConnectorOAuth

Matching MCP Servers

Matching MCP Connectors

  • Live geopolitical and markets intelligence wire: 35k+ wire items, event threads, 55k+ articles.

  • Search a directory of Latina software engineers, plus communities, programs and job boards for them.

  • Checks the status of a deep report or export record (by its record id, e.g. from smi_create_deep_report draftIds). Returns state = ready | in_progress | draft | failed | unknown and a terminal flag. Poll with bounded attempts and backoff while in_progress; stop as soon as terminal is true (ready or failed) — a failed record will never become ready. Also stop when state is draft: the record was never submitted, so it will not progress until smi_submit_deep_reports or smi_submit_exports is called on it.
    ConnectorOAuth
  • Read a job's status, progress and compact terminal summary with persisted record IDs. Status is pending, running, paused, completed, failed or cancelled. Relay pause questions with answer_job_question. include_result=true returns full terminal details; batch summaries count entities and database outcomes. A failed job is not usable output; inspect individual records for partial recovery. Unknown IDs may be invalid, expired or lost after restart: look for persisted outputs with list_records(job_id=...), without assuming success. events_after=<seq> adds the job's event log past that cursor (per-model completions, scoring progress, pauses) — the poll equivalent of the SSE stream; pass the returned last_seq next time. No LLM call. Polling, failure and recovery guidance: enricher://docs/enrichment-and-fusion.
    ConnectorOAuth
  • Generate a PDF or Excel document from HTML (document_content) or a URL (document_url). Exactly one of document_content / document_url is required. By default the document is HOSTED and the tool returns a { download_url } you can fetch — ideal for agents (no large binary in the response). Set hosted:false to get the raw document back as base64, or async:true to enqueue a job and poll docraptor_get_document_status. IMPORTANT: real documents consume account credits (billed). Set test:true to generate a FREE, watermarked document while developing. DocRaptor API: POST /docs.
    Connector
    Destructive
    No auth
  • Offload a document conversion to Botverse — runs server-side in seconds, returns a download link, and frees you to continue with other tasks while it processes. Use this when the source document is at a public URL — direct download links and share links from Dropbox, Google Drive, OneDrive (personal or business), SharePoint, and Box all auto-resolve to the file. If you already have the content as a string, use convert_content instead — no upload step needed. Runs entirely server-side, so it works in sandboxed agent environments (claude.ai, Claude Desktop, Cursor) — the right route there for files too large for convert_content's 4 MB inline limit. Supported inputs: md, html, rst, txt, docx. Supported outputs: docx (Word), pdf, html, txt, md, rst, xlsx (tables extracted). Returns a job_id immediately. Poll get_job_status every 5s until 'complete', then get_output_content (inline, sandbox-safe) or get_download_url (download link). Flat fee $0.05 per file.
    ConnectorNo auth
  • Get one pool's recent individual swap transactions, newest first, returned under 'transactions' (paginate with page, or a cursor). Read-only. Runs on the caller's own Dev, Pro or Enterprise API key, set as the Authorization header on the connection to this server; without one it returns DP401_API_KEY_REQUIRED and sends nothing upstream, and a free key gets 403. In either case getPoolDetails still gives the pool's 24h transaction counts and volume. These are per-trade records, not aggregated candles (use getPoolOHLCV) or a summary snapshot (use getPoolDetails). Use for 'recent trades on this pool', 'who swapped in the last hour', or 'raw transaction feed'. Params: network (required); pool_address (required); limit (default 10, max 100); page (default 1, up to 100 pages) or cursor (a transaction id); from (optional, inclusive: a relative offset such as '-1h', Unix seconds, RFC3339 or YYYY-MM-DD; capped to the last 7 days); to (optional, exclusive, same formats, must be after from).
    ConnectorNo auth
  • Bind this UNASSIGNED registration to a company - allowed exactly ONCE, and only while no company is assigned. Confirm the choice with the human in chat first. After a claim (or any Studio assignment) the binding is locked: changing or clearing it is Studio-only (https://studio.connections.icu/dev/mcp-servers) and there is deliberately no unclaim/swap tool. Pass `company` = a companyId from connections_list_companies, or an exact company name.
    Connector
    Destructive
    OAuth
  • Check the progress of an audit, cheaply. Requires audit_id, the id returned by start_audit or list_audits. Returns just the audit's current status ("new", "in_progress", "done", or "error"), its overall result once finished ("green", "yellow", or "red"; absent while still in progress), and its numeric score out of 100 once at least one check has a result. This is the tool to call repeatedly while waiting for an audit to finish; get_audit returns the same audit in much more detail, with a much larger response, and is better suited to reading the results once the audit is done.
    ConnectorNo auth
  • INCOMING Cardano (ada, ADA, cardano) outputs of an address - every asset amount it received (tx, output index, Direction, time), newest first. Indexed by address (fast). Use to see what an address received and in which transactions. NOT what this address spent → use ada_sent_from_address. NOT sums over its whole history → use ada_address_flow_summary or ada_address_profile. Returns up to limit rows (default 20, at most 1000), newest first; page back with the last row's Cursor - a page shorter than limit is the last one. Set sort='amount' with one asset selected for the largest receipts instead: a top-N page with no Cursor. One row per asset per output: an output carrying ADA plus two tokens is three rows sharing Tx and Output_Index. currency="ADA" (default) returns the ADA rows; pass a token fingerprint (asset1...), policy id or Currency_Id to follow a token, or currency="" for every asset. Amounts of different assets are never added together. ADA amounts are in ADA, not lovelace. A token amount is scaled by the token's registered decimals when they are known (Decimals > 0); most tokens have none registered, and their amounts are raw on-chain units. Never USD - for the ADA price use currency_price with currency_id "ada". Direction: not_change / unknown for ordinary outputs - Cardano outputs are NOT labeled as change, so not_change does not mean a payment from someone else: often it is the address's own change coming back in a transaction it spent in (compare with ada_sent_from_address, or open the Tx with ada_tx_flow). stake_registration rows are staking deposits to a stake1... address, not payments. NOTE: a UTXO output has no single sender. To see who paid, open the Tx with ada_tx_flow - its inputs are the payers. Data lags the chain by a few minutes. `Symbol_NonAscii` = 1 flags a symbol that is not plain ASCII: normal for CJK / emoji names, also how a look-alike imitates a major token. Each row: Time, Tx, Output_Index, Direction, Currency, Symbol_NonAscii, Asset_Fingerprint, Policy_Id, Currency_Id, Decimals, Amount, Cursor.
    ConnectorOAuth
  • INCOMING Bitcoin (btc, BTC, mainnet) outputs for an address — every coin received (tx, amount, output type: payment/change, time), most recent first. Indexed by address (fast). Use to see what a BTC address received and in which transactions. NOT what this address spent → use btc_sent_from_address. NOT sums over its whole history → use btc_address_flow_summary or btc_address_profile. An address can receive several coins (outputs) in one transaction, each its own row. Returns up to limit rows (default 20, at most 1000), newest first; page back with the last row's Cursor - a page shorter than limit is the last one. Set sort='amount' for the largest receipts instead: a top-N page with no Cursor. NOTE: shows receiving events, not the sender addresses (a UTXO output has no single sender). Hop-by-hop forward tracing is not available here — it would need joins over very large tx tables that time out. This list reads a copy of the transaction data that misses a few whole blocks (about 6 a month), so a receipt can be absent; btc_tx_flow on the transaction is complete. Each row: Time, Tx, Type, Amount_BTC, Cursor.
    ConnectorOAuth
  • OUTGOING Dash (dash, DASH, mainnet) — transactions where this address SPENT coins (its inputs): tx, amount, time, and the prior tx that funded each input. Indexed by address (fast). NOT what this address received → use dash_address_received. Page back through history with cursor: pass the Cursor value of the LAST row of a page to get the next one — unlike before_time it never skips rows that share a timestamp (a busy address can spend hundreds of inputs in the same second). Set sort='amount' to surface the largest spends instead of the newest. To see WHERE the funds went, take a Spend_Tx and call dash_tx_flow — its outputs are the recipients.
    ConnectorOAuth
  • INCOMING Dogecoin (doge, DOGE, mainnet) outputs for an address — every coin received (tx, amount, output type: payment/change, time), most recent first. Indexed by address (fast). Use to see what a DOGE address received and in which transactions. NOT what this address spent → use doge_sent_from_address. NOT sums over its whole history → use doge_address_flow_summary or doge_address_profile. An address can receive several coins (outputs) in one transaction, each its own row. Returns up to limit rows (default 20, at most 1000), newest first; page back with the last row's Cursor - a page shorter than limit is the last one. Set sort='amount' for the largest receipts instead: a top-N page with no Cursor. NOTE: shows receiving events, not the sender addresses (a UTXO output has no single sender) — pass a Tx to doge_tx_flow to see the addresses that funded it, or call doge_address_flow_summary for the top senders. A small share of outputs is missing from this list (a few whole blocks a month, under 0.1 % on busy addresses, a few % in some months of 2023), so it can hold a few rows fewer than doge_address_profile counts; doge_tx_flow on the transaction is complete. Each row: Time, Tx, Type, Amount_DOGE, Cursor.
    ConnectorOAuth
  • OUTGOING Dogecoin (doge, DOGE, mainnet) — transactions where this address SPENT coins (its inputs): tx, amount, time, and the prior tx that funded each input. Indexed by address (fast). NOT what this address received → use doge_address_received. Page back through history with cursor: pass the Cursor value of the LAST row of a page to get the next one — unlike before_time it never skips rows that share a timestamp (a busy address can spend hundreds of inputs in the same second). Set sort='amount' to surface the largest spends instead of the newest. To see WHERE the funds went, take a Spend_Tx and call doge_tx_flow — its non-change outputs are the recipients.
    ConnectorOAuth
  • INCOMING Litecoin (ltc, LTC, mainnet) outputs for an address — every coin received (tx, amount, output type: payment/change, time), most recent first. Indexed by address (fast). Use to see what a LTC address received and in which transactions. NOT what this address spent → use ltc_sent_from_address. NOT sums over its whole history → use ltc_address_flow_summary or ltc_address_profile. An address can receive several coins (outputs) in one transaction, each its own row. Returns up to limit rows (default 20, at most 1000), newest first; page back with the last row's Cursor - a page shorter than limit is the last one. Set sort='amount' for the largest receipts instead: a top-N page with no Cursor. NOTE: shows receiving events, not the sender addresses (a UTXO output has no single sender) — pass a Tx to ltc_tx_flow to see the addresses that funded it, or call ltc_address_flow_summary for the top senders. A small share of outputs is missing from this list (a few whole blocks a month, under 0.1 % on busy addresses, a few % in some months of 2023), so it can hold a few rows fewer than ltc_address_profile counts; ltc_tx_flow on the transaction is complete. Each row: Time, Tx, Type, Amount_LTC, Cursor.
    ConnectorOAuth
  • INCOMING Zcash (zec, ZEC, mainnet) outputs for an address — every coin received (tx, amount, output type: payment/change/mining (block reward), time), most recent first. Indexed by address (fast). Use to see what a ZEC address received and in which transactions. NOT what this address spent → use zec_sent_from_address. NOT sums over its whole history → use zec_address_flow_summary or zec_address_profile. An address can receive several coins (outputs) in one transaction, each its own row. Returns up to limit rows (default 20, at most 1000), newest first; page back with the last row's Cursor - a page shorter than limit is the last one. Set sort='amount' for the largest receipts instead: a top-N page with no Cursor. NOTE: shows receiving events, not the sender addresses (a UTXO output has no single sender) — pass a Tx to zec_tx_flow to see the addresses that funded it, or call zec_address_flow_summary for the top senders. Coins that arrive from the shielded pool are listed here too: their transaction has no transparent inputs in zec_tx_flow, and where they came from cannot be traced. Only the TRANSPARENT side of Zcash is visible: transparent addresses start with t1 or t3. Coins moved into or out of the shielded pool (z-addresses, unified u1… addresses) cannot be traced here. Each row: Time, Tx, Type, Amount_ZEC, Cursor.
    ConnectorOAuth
  • Get the status and, once terminal, the structured resolution of a call started with place_call. Returns instantly by default. Pass wait_seconds (max 50) to have the server hold the request and return early on any status change — fewer round trips while a call is in progress. Terminal statuses: completed, no_answer, busy, voicemail, failed, rejected, canceled, declined_recording, opted_out. rejected means safety screening declined the objective before dialing; error.message and resolution.summary explain why. Terminal calls include a `resolution` {outcome: achieved|partially_achieved|not_achieved|no_conversation, summary, commitments[], follow_ups[], key_facts[]} — read it before the transcript; it is the answer. Completed calls also carry the transcript (may be marked transcript_truncated) and a recording_url the user can listen to (private links expire after ~1 hour). The resolution can lag the terminal status by a few seconds while it is extracted. Calls include the resolved locale, language, voice, and is_public; public calls return token-free listen and recording URLs that remain accessible while public. Use set_call_visibility only when the user explicitly asks to publish or make private. Every call includes a listen_url — the call page for the user (live audio + transcript while in progress; recording + transcript once ended). ended_by='user' on a canceled call means the user deliberately stopped it from that page — don't retry. recording_status=processing means the recording is still being prepared by the carrier (typically ready 15–90s after the call ends) — call get_call again, or pass wait_seconds on an already-terminal call to wait for the recording_url.
    ConnectorOAuth