revylai/revyl-cli · Archived

revyl-mcp-dev-loop

Optional MCP dev-first mobile loop for screenshot-observe-action execution. Not started by the Cursor plugin.

First seen May 15, 2026

Installation

$ npx skills add revylai/revyl-cli --skill revyl-mcp-dev-loop

Stronger alternatives

This repository is archived — consider an actively maintained alternative.

Similar popular skills

Related neighbors and high-traction skills in the same topics — useful to compare before installing.

Also in this package

Other skills from revylai/revyl-cli · top by installs.

npx skills add revylai/revyl-cli

Browse all from revylai/revyl-cli

More details

Agent compatibility

Declared targets from SKILL.md / docs. Unmarked agents are not listed — the skill may still install via the CLI.

Claude Code Not declared
Cursor Not declared
Codex Not declared
GitHub Copilot Not declared
Windsurf Not declared
Gemini CLI Not declared
Cline Not declared
OpenCode Not declared

Repository health

Stars 510
License MIT
Default branch main
Open issues 1
Status Archived

Package contents

Files included with this skill beyond the listing page.

  • skill md SKILL.md 5,236 B
  • docs SUMMARY.md 135 B

History

  1. First seen on skills.sh
  2. First recorded snapshot · 3 installs

SKILL.md

Revyl MCP Dev Loop Skill

This skill is for users who opt into custom MCP. The Cursor plugin does not start an MCP server. Add a personal MCP entry with a literal command such as revyl or /usr/local/bin/revyl, never ${...}.

Use this skill for the full flow:

  1. Start dev loop equivalent.
  2. Execute screenshot-observe-action cycles.

Default Operating Mode

Always prefer dev-loop flow before plain device-only flows:

  1. Call startdevloop. Pass profile and platform when repository

evidence determines the named recipe; never invent an active/default value.

  1. On success, share viewer_url as a clickable link and confirm the session is active. When the inline Revyl app exposes Open live device, the user may use it to hand the URL to the host browser; the link remains the portable fallback.
  2. On a setup failure, follow the single structured remediation action and

retry startdevloop once.

  1. Call screenshot() and begin interaction.

Fallback to plain device session only when dev loop is unavailable.

Execution Guardrails

  1. First tool call must be startdevloop.
  2. Do not call listing tools unless the user explicitly asks.
  3. Treat next_steps as advisory only.
  4. Re-anchor with screenshot() before state-dependent actions.
  5. Express device actions through the current natural-language schema, for example interact(task="Tap the Sign In button"). Do not calculate or supply coordinates.
  6. Use setup_status only when the user explicitly asks for setup diagnostics.

Its remediation object is the read-only view of the same recovery plan: follow checkcommand before applycommand when both are present.

  1. Never claim that a Cloud Agent opened the viewer on the user's local computer. Cloud tools run on the remote VM; the inline open control and clickable URL are client-side handoffs.

Setup Recovery

Handle setup outcomes as bounded recovery steps:

  • authrequired / authexpired / authinvalid: run remediation.command once, then retry startdevloop. If the command cannot complete, post outcome.authorizationurl as a clickable markdown link and stop until the user approves; that URL is a live approval request Revyl already registered, and it works from any browser.
  • cloudsecretrequired: run remediation.command once to bridge the hosted agent's injected remediation.envname, then retry startdevloop. If that command reports no key in the environment, post outcome.authorizationurl as a clickable link and tell the user that adding remediation.env_name as a Runtime Secret plus a new Cloud session is the durable fix.
  • projectnotinitialized: use remediation.command to pull an existing UI-created or server-managed project, or remediation.alternativecommand to initialize a genuinely new project. Use repository and user context to choose; ask when unclear. Run only the selected exact command with remediation.workingdirectory, then retry startdevloop once. The executable may be the plugin-pinned runtime rather than revyl on PATH; do not rewrite either command or add --force.
  • projectlegacyconfig: run the exact JSON remediation.checkcommand first and review its canonical proposal and complete omission ledger. Then run the exact remediation.applycommand once to create the backup and apply that proposal. If the ledger is lossy, reconcile the migrated file against the reported backup before retrying startdevloop; otherwise retry directly. Do not rewrite either command, skip the check, or hide reported omissions or ambiguities.
  • projectoutsidegit: select a project directory inside an active Git worktree from repository context and retry startdevloop with that exact path as projectdir. Treat remediation.envname as the durable runtime configuration hint, not as permission to invent a path. If no intended Git worktree is evident, ask the user to choose one.
  • projectambiguous: inspect remediation.candidateroots, select the intended project from repository context, and retry with that exact root as projectdir. If the intended project is unclear, ask the user to choose. Do not initialize another project or retry without an explicit projectdir.
  • projectinvalid: report remediation.configpath and wait for it to be repaired before retrying.

After one remediation and one retry, stop and report any remaining failure. Do not enter a setup loop.

If startdevloop fails with a profile/platform selection error instead of a setup remediation, inspect its valid choices and retry once with exact profile and platform values. Do not guess. If a deprecated platformkey input returns devloopplatformkey_removed, replace it with profile and platform.

Interaction Loop

For each iteration:

  1. screenshot()
  2. State visible UI in one short line.
  3. Take one best action with interact(task="...").
  4. screenshot() to verify.
  5. Repeat.

Short deterministic burst allowance:

  • Up to two actions before verification for obvious two-step entry flows.