Watchgoose

क्रोन जॉब्स और आवर्ती कार्यों की निगरानी करें, प्रोजेक्ट-स्कोप्ड Watchgoose कनेक्शन के माध्यम से

दस्तावेज़

MCP Server for Cron Job Monitoring

Connect Claude, ChatGPT, Cursor, Codex, and other AI assistants to Watchgoose to review and set up cron job checks.

The Model Context Protocol (MCP) lets supported AI clients use Watchgoose tools through a project-scoped connection you approve.

Available in

Watchgoose is available in the Claude connector directory.

Watchgoose is listed in ChatGPT plugins for GPT and Codex.

Watchgoose is listed in the official MCP Registry.

The watchgoose-mcp package is available on npm.

The Watchgoose Monitoring plugin, with the hosted server and five agent skills, is in the Claude plugin directory for Claude Code, Cowork, and the Claude apps.

Watchgoose is listed in Raycast's Model Context Protocol Registry extension and on cursor.directory.

The Watchgoose plugin with the hosted server and five agent skills is published at pixeware/watchgoose-plugin for Gemini CLI, Grok Build, and other agents.

How Connecting Works {: #how-it-works }

Add the Watchgoose server to your AI client, or install the Watchgoose plugin. The steps for each client are below.
Sign in. Installing a plugin or adding the server doesn't connect it yet. The client opens Watchgoose in your browser the first time it connects. If it doesn't, start the sign-in yourself as described for your client below.
Approve the connection. Choose one project and the access level, then confirm with your password or an emailed code. See Approve the connection.
Ask. Go back to your client and try one of the first requests.

You need a Watchgoose account. If you don't have one, the sign-in page lets you create a free account and returns you to the approval step.

Choose Your Client

Claude · Claude Code · ChatGPT and Codex · Cursor · VS Code · Cline · Raycast · Gemini CLI · Grok Build · project API key · other remote clients · troubleshooting

Connect Claude {: #connect-claude }

Open the Watchgoose page in the Claude connector directory, linked above, and click Connect. You can also open Settings > Connectors in Claude, add a custom connector, and enter:

https://mcp.watchgoose.com/mcp

Claude opens Watchgoose in your browser. Sign in, choose one project, review the requested access, and continue. Read-only access is selected by default.

To add the five agent skills as well, install the Watchgoose Monitoring plugin from the Claude plugin directory instead. It includes the same connector.

Connect Claude Code {: #connect-claude-code }

Add the hosted Streamable HTTP server for your user:

claude mcp add --transport http --scope user watchgoose https://mcp.watchgoose.com/mcp

Start Claude Code and complete the browser authorization when prompted. Run claude mcp get watchgoose to inspect the saved connection.

To get the server and the five agent skills together, run /plugin in Claude Code, or use Browse plugins in the Claude desktop app, and install Watchgoose Monitoring.

Sign in after installing. A newly added server or plugin shows as needing authentication until you sign in. The server's name in Claude Code depends on how you added it:

Plugin: run /mcp in a Claude Code session, select plugin:watchgoose-monitoring:watchgoose, and choose Authenticate.
claude mcp add: run /mcp, select watchgoose, and choose Authenticate, or sign in from your shell:

claude mcp login watchgoose

Your browser opens Watchgoose. After you approve the connection, /mcp shows the server as connected. If Claude Code later asks you to sign in again, open /mcp and choose Re-authenticate. Clear authentication in the same menu removes the stored sign-in.

Connect ChatGPT and Codex {: #connect-chatgpt-codex }

Open the Watchgoose plugin in ChatGPT plugins, linked above, and connect it. Codex uses the same plugin. Sign in to Watchgoose in the browser, choose one project, and approve access. The plugin also adds the five agent skills.

To add only the server to the Codex CLI, run:

codex mcp add watchgoose --url https://mcp.watchgoose.com/mcp
codex mcp login watchgoose

codex mcp login opens Watchgoose in your browser. Run codex mcp list to check that watchgoose is signed in. In the Codex IDE extension and desktop app, select Authenticate next to watchgoose in the MCP server list.

Connect Cursor {: #connect-cursor }

Add this entry to .cursor/mcp.json in your project, or to your user MCP configuration:

{
  "mcpServers": {
    "watchgoose": {
      "url": "https://mcp.watchgoose.com/mcp"
    }
  }
}

Cursor opens Watchgoose in your browser when it first connects. Sign in, choose one project, and approve access. If the browser doesn't open, find watchgoose in the MCP section of Cursor Settings and use its sign-in or authentication action there.

Connect VS Code {: #connect-vs-code }

Create .vscode/mcp.json in your workspace:

{
  "servers": {
    "watchgoose": {
      "type": "http",
      "url": "https://mcp.watchgoose.com/mcp"
    }
  }
}

Run MCP: List Servers, start watchgoose, and complete the browser authorization when VS Code asks. Allow VS Code's authentication prompt for mcp.watchgoose.com when it appears.

Connect Cline {: #connect-cline }

Open MCP Servers > Configure MCP Servers and add this entry to cline_mcp_settings.json:

{
  "mcpServers": {
    "watchgoose": {
      "type": "streamableHttp",
      "url": "https://mcp.watchgoose.com/mcp"
    }
  }
}

Keep "type": "streamableHttp" exactly as written. Without it, Cline falls back to SSE and the connection fails. When Cline asks you to authenticate, sign in to Watchgoose in the browser and choose one project.

Connect Raycast {: #connect-raycast }

Install the Model Context Protocol Registry extension from the Raycast Store.
Run Search Servers and find Watchgoose.
Open the action panel and choose Install Server > Raycast.

Raycast connects to https://mcp.watchgoose.com/mcp directly and asks you to sign in to Watchgoose. You don't need Node.js for this. Using MCP servers in Raycast AI requires a Raycast Pro subscription.

The same Install Server menu can add Watchgoose to other installed clients, such as Claude or Cursor. Those installs run the mcp-remote proxy through npx, so they need Node.js. If you see spawn npx ENOENT, install Node.js and restart Raycast, or connect the client directly as described on this page.

Connect Gemini CLI {: #connect-gemini-cli }

Install the Watchgoose extension, which adds the hosted server and the five agent skills:

gemini extensions install https://github.com/pixeware/watchgoose-plugin

Restart Gemini CLI and complete the browser authorization when prompted. If the browser doesn't open, run /mcp auth watchgoose in Gemini CLI.

Connect Grok Build {: #connect-grok-build }

Install the Watchgoose plugin, which adds the hosted server and the five agent skills:

grok plugin install pixeware/watchgoose-plugin --trust

Connect the watchgoose server when Grok asks and approve access in the browser.

Use a Project API Key Instead {: #project-api-key }

Clients without remote OAuth support can run the watchgoose-mcp npm package locally with Node.js 20 or later and a project API key from Project settings > API Access. This entry uses the mcpServers format of Claude Desktop, Cursor, and Cline:

{
  "mcpServers": {
    "watchgoose": {
      "command": "npx",
      "args": ["-y", "watchgoose-mcp"],
      "env": {
        "WATCHGOOSE_API_KEY": "hcr_your_project_key"
      }
    }
  }
}

VS Code uses a different format in .vscode/mcp.json: put the entry under "servers" instead of "mcpServers" and add "type": "stdio".

An hcr_ key is read-only. An hcw_ key also allows pings, integrations, and check changes, but write tools stay disabled until you also set "WATCHGOOSE_ENABLE_WRITES": "true" in env. Put the key in the client's configuration file, never in a chat with the AI assistant.

Other Remote Clients {: #other-remote-clients }

Use https://mcp.watchgoose.com/mcp in clients that support remote Streamable HTTP MCP servers, OAuth 2.1, PKCE, and Dynamic Client Registration. The OAuth issuer is https://mcp.watchgoose.com. You do not paste a Watchgoose API key into a remote client.

Approve the Connection {: #approve-the-connection }

Every client uses the same approval screens in your browser.

1. Choose the project and access. Pick the project this client may use. Keep Read-only to let the assistant list checks and read their status history. Choose Read and write if you want it to create, update, pause, resume, or delete checks, and to see recent pings and integration names. Read and write appears only when the client requests it and you can modify the selected project.

{: width="456" height="606" }

2. Confirm it's you. If you signed in to Watchgoose in the last 15 minutes, for example because you just signed up or signed in while connecting, there is nothing more to do: your browser goes straight back to the client.

Otherwise Watchgoose asks you to confirm. If your account has a password, enter it. If you use an authenticator app for two-factor sign-in, enter its code. If neither applies, Watchgoose emails a six-digit code to your account address. The code works for 15 minutes, and send a new code emails a fresh one. Accounts created with GitHub or an email sign-in link have no password unless you set one in Account settings.

{: width="456" height="298" }

{: width="456" height="273" }

After Approve Connection, your browser returns to the client and the connection is ready. Finish both steps within 30 minutes of starting, or start the connection again from the client.

First Requests to Try {: #first-requests }

"List my Watchgoose checks and tell me which are down or late."
"What happened to my backup check this week?"
"Which checks are paused, or still new without a successful ping?"
"Create a Watchgoose check for my nightly database backup: cron 0 2 * * *, Europe/London, 30 minutes of grace time." (needs Read and write)
"Audit the cron jobs in this repository and tell me which have no Watchgoose monitoring. Don't change anything." (uses the agent skills)

Finish Setting Up a New Check {: #finish-setup }

When the assistant creates a check, the check starts in the new state: no success signal has been recorded yet. Your job's signals start two kinds of monitoring:

Schedule monitoring starts with the first success signal, a request to the plain ping URL without /start, /fail, or /log. From then on, Watchgoose expects the next success signal on schedule, within the grace time.
Runtime monitoring starts with a /start signal. If the run doesn't send a success or failure signal within the grace time after /start, the check goes down, even if it hasn't recorded a success signal yet.

The assistant never sees ping URLs, so you add the pings yourself:

Open the check in the Watchgoose dashboard and copy its ping URL.
Call the URL when the job finishes successfully, for example backup.sh && curl -fsS -m 10 --retry 5 <ping URL>. See Monitoring cron jobs for complete examples.
Keep the URL in the job's configuration or secret store, not in chat or in source code.

A /log signal adds an entry and changes nothing else. A /fail signal or a non-zero exit status marks the check down. A request that your filtering rules ignore changes nothing. A paused check that you resume returns to new, even if it received pings before, and schedule monitoring continues with its next success signal. Ask the assistant "Which checks are still new?" to find checks that haven't recorded a success signal yet.

Troubleshooting {: #troubleshooting }

Tools fail or show "unauthorized" after installing {: #unauthorized }

The client is installed but hasn't been signed in. Sign in once:

Claude Code plugin: run /mcp, select plugin:watchgoose-monitoring:watchgoose, and choose Authenticate.
Claude Code with claude mcp add: run /mcp, select watchgoose, and choose Authenticate, or run claude mcp login watchgoose.
Codex CLI: run codex mcp login watchgoose. In the Codex app, select Authenticate next to watchgoose.
Gemini CLI: run /mcp auth watchgoose.
Cursor, VS Code, Cline, and Raycast: open the client's MCP server list and use the sign-in or authentication action next to watchgoose.
Claude and ChatGPT: open the Watchgoose connector or plugin and click Connect.

"This connection request has expired" {: #authorization-request-expired }

The approval took longer than 30 minutes, or you opened the sign-in email in a different browser or on another device. Watchgoose keeps the pending approval in the browser where you started. Nothing was connected. Go back to your client and connect Watchgoose again, and open any sign-in email in that same browser. You also see this page if you reload the confirmation page after approving. In that case the connection is already complete; go back to your client.

The assistant can't create or change checks {: #read-only-connection }

The connection is read-only. Revoke it under Account settings > MCP Connections, disconnect Watchgoose in the client, connect again, and choose Read and write. If that option doesn't appear, either the client didn't request write access or you can't modify any of your projects. Check the client's settings for a read-only mode, or ask the project owner for read-write team access. If the option appears but approval fails for one project, your team access to that project is read-only.

A check created by the assistant stays `new` {: #check-stays-new }

The check hasn't recorded a success signal yet. See Finish setting up a new check.

The assistant sees the wrong project {: #wrong-project }

Each connection covers one project. Revoke it and connect again, choosing the other project. To use two projects, connect a second client or switch the connection when you need it.

The client asks you to approve again {: #approve-again }

A connection lasts 30 days from its last use, and at most one year from approval. Approve it again to continue.

Cline can't connect {: #cline-sse }

Check that the entry has "type": "streamableHttp". Without it, Cline uses SSE, which Watchgoose doesn't support.

Raycast shows `spawn npx ENOENT` {: #raycast-npx }

You installed Watchgoose into another client through Raycast, and that install needs Node.js. Install Node.js and restart Raycast, or connect the client directly.

Still stuck {: #support }

Email support@watchgoose.com with your client's name and the exact error message. Never send an API key or ping URL.

Project Access

Each connection is limited to one project. The consent screen always starts with Read-only access. It offers Read and write only when the client requests the mcp:write scope and you have permission to modify the selected project.

Changing a read-only connection to read and write requires a new authorization. Revoke the existing connection under Account settings > MCP Connections, disconnect it in the client, and connect again. Review every requested write operation in the client before approving it.

{: width="968" height="416" }

Tools

Tool	What it does	Required OAuth scope
`list_checks`	Lists checks, with optional slug or tag filters.	`mcp:read`
`get_check`	Gets one check and its current state and schedule.	`mcp:read`
`list_flips`	Lists retained status changes. `up: 1` means the check became up; `up: 0` includes down, paused, and new after resume. A pause or resume that changes status records a flip.	`mcp:read`
`list_pings`	Lists recent signals without source or body data.	`mcp:read` + `mcp:write`
`list_channels`	Lists integration names and kinds for assignments.	`mcp:read` + `mcp:write`
`create_check`	Creates a simple, cron, or OnCalendar check.	`mcp:read` + `mcp:write`
`update_check`	Changes selected fields on a check.	`mcp:read` + `mcp:write`
`pause_check`	Pauses monitoring without deleting a check.	`mcp:read` + `mcp:write`
`resume_check`	Resumes a paused check.	`mcp:read` + `mcp:write`
`delete_check`	Permanently deletes a check and its retained history.	`mcp:read` + `mcp:write`

A connection stays signed in while the AI client uses it. Each time the client refreshes its access, the connection is extended to 30 days from that moment, up to one year after you approved it. After 30 days without use, or after one year, the client asks you to approve the connection again. Clients may request the offline_access scope, but it isn't required and doesn't expose additional tools.

Identifiers and Private Fields

AI clients address checks by their stable unique_key. The MCP server uses internal identifiers only when calling the Management API and removes them from tool results.

The connected AI client never receives check UUIDs or ping URLs, integration channel UUIDs, source IP addresses, user agents, run IDs, body URLs, or ping body contents. Ping results include only signal type, date, sequence number, scheme, method, and duration. The server does not request ping bodies.

Credentials, Storage, and Revocation

Watchgoose exchanges a single-use, five-minute handoff for a delegated project credential. The hosted MCP service processes that credential in memory for API requests and stores it only in encrypted OAuth state. It never returns the credential, OAuth tokens, or API keys to the AI client as tool output.

OAuth client, authorization, session, grant, and delegated credential state is stored in service-owned SQLite on the single production host in one region. The state and its identifiers are encrypted or keyed at rest and follow the normal production backup rotation. The MCP application adds no telemetry. The production proxy keeps normal security and operational access logs, including source address, user agent, full request URI including its query string, method, status, and timestamp. It removes authorization and cookie headers from those logs and skips the OAuth callback entirely. It also removes the credential-bearing X-Api-Key header used for project API requests. Access-log fields are never returned as tool output.

Watchgoose keeps connection metadata and records each MCP API operation, route, method, outcome, HTTP status, and timestamp. Audit events are retained for 90 days. Revoke a connection under Account settings > MCP Connections to block future project API access. The client must complete authorization again to reconnect.

Read the Privacy Policy for the complete processing and retention boundary.

{"@context":"https://schema.org","@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https://watchgoose.com/"},{"@type":"ListItem","position":2,"name":"Documentation","item":"https://watchgoose.com/docs/"},{"@type":"ListItem","position":3,"name":"MCP Server for Cron Job Monitoring","item":"https://watchgoose.com/docs/mcp/"}]}