Telescope

Passive runtime inspector for Flutter. Read by humans, queried by AI agents.
HTTP, logs, exceptions, debugPrint, DB queries, and Magic events captured over VM Service extensions, surfaced as telescope:* CLI commands and as 10 MCP tools for Claude Code.

Documentation · pub.dev · Issues

Why Telescope?

Stop pasting stack traces into Claude. Let your agent read them itself.

Debugging a running Flutter app has always required a mix of print statements, custom logging sinks, and network proxies that each tell a different slice of the story. When something breaks, you stitch together log files, Charles captures, and Flutter DevTools windows to reconstruct what happened. The AI workflow is worse: you copy the stack trace out of the console, paste it into Claude Code, copy the failing HTTP response, paste it back, repeat.

Telescope closes that loop. Passive watchers and 12 VM Service extensions register at startup. Every HTTP request, log line, exception, debugPrint call, DB query, and Magic-framework lifecycle event lands in a ring buffer. CLI commands (telescope:tail, telescope:requests) stream the buffers for humans; 10 MCP tools (telescope_requests, telescope_exceptions, telescope_tail, ...) expose the same buffers to AI coding agents like Claude Code, Cursor, and Codex. No copy-paste, no screenshots, no SaaS account. Debug-only; kDebugMode tree-shakes the entire subsystem on release builds.

# One-shot self-bootstrap install (works from a fresh consumer)
flutter pub add fluttersdk_telescope
dart run fluttersdk_telescope telescope:install

The install command scaffolds the consumer artisan harness if it is missing, runs plugin:install fluttersdk_telescope, and patches lib/main.dart so TelescopePlugin.install() runs before Magic.init() (or before runApp on vanilla Flutter). Everything is gated under kDebugMode; release builds tree-shake the entire subsystem.

After install, the consumer gets the artisan fast-cli at ./bin/fsa (native AOT, ~110ms warm startup) for every subsequent telescope command. dart run fluttersdk_telescope <cmd> keeps working as a slower (~3s cold) fallback.

Features

Quick Start

Option A (recommended): one-shot install

Add the dependency, then let telescope bootstrap itself via its own CLI entry point. No prior fluttersdk_artisan wiring is required; telescope's binary carries the artisan substrate so the install works from a fresh consumer:

flutter pub add fluttersdk_telescope
dart run fluttersdk_telescope telescope:install

The command scaffolds the consumer artisan harness if it's missing (bin/dispatcher.dart + lib/app/_plugins.g.dart), runs plugin:install fluttersdk_telescope, and patches lib/main.dart so TelescopePlugin.install() runs before Magic.init() (or before runApp on vanilla Flutter). Idempotent; safe to re-run.

For everyday repeat usage, the consumer's ./bin/fsa (artisan native AOT binary built during install) gives ~110ms warm startup:

./bin/fsa telescope:tail
./bin/fsa telescope:requests

dart run fluttersdk_telescope <cmd> remains a slower (~3s cold) fallback that always works without the AOT bundle.

Option B: manual wiring

1. Add the dependency

# pubspec.yaml
dependencies:
  fluttersdk_telescope: ^0.0.4

2. Install in main.dart

Install Telescope before Magic.init() (or before runApp for plain Flutter). Wrap every install call in kDebugMode so the entire tooling branch is tree-shaken in release builds.

import 'package:flutter/foundation.dart';
import 'package:fluttersdk_telescope/telescope.dart';
import 'package:magic_devtools/telescope.dart'; // magic_devtools dev_dependency (Magic-stack apps only)

void main() async {
  WidgetsFlutterBinding.ensureInitialized();

  // 1. Install Telescope core (auto-installs LogWatcher + registers VM extensions).
  if (kDebugMode) {
    TelescopePlugin.install();

    // 2. Opt-in watchers registered after install().
    TelescopePlugin.registerWatcher(ExceptionWatcher());
    TelescopePlugin.registerWatcher(DumpWatcher());
  }

  // 3. Magic-side adapters run AFTER Magic.init() because they resolve
  //    framework internals (Http facade, Gate manager) from the IoC container.
  await Magic.init(configFactories: [...]);

  if (kDebugMode) {
    // MagicTelescopeIntegration ships in magic_devtools (not magic core).
    // Add magic_devtools to dev_dependencies in pubspec.yaml.
    MagicTelescopeIntegration.install();
  }

  runApp(MyApp());
}

3. Register the Artisan provider (MCP tools)

In the consumer's bin/dispatcher.dart (generated by dart run fluttersdk_artisan install), telescope is auto-discovered through lib/app/_plugins.g.dart after plugin:install fluttersdk_telescope. If you are wiring providers by hand, add FluttersdkTelescopeArtisanProvider() to the baseProviders list so the 9 telescope_* MCP tools are visible to Claude Code and other MCP clients:

import 'package:fluttersdk_artisan/artisan.dart';
import 'package:fluttersdk_telescope/cli.dart' show FluttersdkTelescopeArtisanProvider;

exit(await runArtisan(
  args,
  baseProviders: [
    FluttersdkTelescopeArtisanProvider(),
    // ...other providers (DuskArtisanProvider, etc.)
  ],
));

Watchers

MCP Tools

Exposed via TelescopeArtisanProvider when the consumer registers it (auto-wired by telescope:install through lib/app/_plugins.g.dart + bin/dispatcher.dart). All tools route through ext.telescope.* VM Service extensions and require a running Flutter app.

CLI Commands

Registered via TelescopeArtisanProvider.commands(). After telescope:install you can invoke any command three ways: through the consumer's fast-cli (./bin/fsa <command>, recommended), through telescope's standalone bin (dart run fluttersdk_telescope <command>), or through the consumer dispatcher fallback (dart run fluttersdk_artisan <command>).

Examples

example/

Vanilla Flutter app (no Magic framework) that exercises every framework-agnostic capture surface: HTTP traffic via the Telescope Dio interceptor, log output via package:logging, uncaught exceptions via ExceptionWatcher, and debugPrint output via DumpWatcher. Demonstrates the minimal install pattern and the in-app overlay dashboard.

cd example && flutter run -d chrome

Architecture

Telescope is subsystem-first under lib/src/, every directory owns a single concern:

lib/
├── telescope.dart              # Single barrel, re-exports the full public API
├── cli.dart                    # Flutter-free codegen barrel (FluttersdkTelescopeArtisanProvider typedef)
└── src/
    ├── watchers/               # TelescopeWatcher abstract contract + LogWatcher, ExceptionWatcher, DumpWatcher
    ├── adapters/               # TelescopeHttpAdapter abstract contract + DioHttpAdapter concrete impl
    ├── records/                # Immutable record types: HttpRequestRecord, LogRecordEntry, ExceptionRecord, etc.
    ├── extensions/             # registerAllTelescopeExtensions() aggregator + per-concern VM Service handlers
    ├── commands/               # TelescopeInstallCommand + 9 read/clear commands
    ├── telescope_store.dart    # 10-buffer ring store (singleton); Queue<T> per buffer + broadcast StreamController<T>
    ├── telescope_plugin.dart   # TelescopePlugin.install() entry + registerHttpAdapter() + registerWatcher()
    └── telescope_artisan_provider.dart  # TelescopeArtisanProvider: 7 commands + 10 MCP tool descriptors

Boot flow:

TelescopePlugin.install()
    ↓
Register default watchers (LogWatcher auto-installs)
    ↓
registerAllTelescopeExtensions()   # 12 ext.telescope.* VM Service extensions, idempotent
    ↓
Consumer registers TelescopeArtisanProvider (auto-wired by `telescope:install` via bin/dispatcher.dart + _plugins.g.dart)
    ↓
artisan mcp:serve   ->   10 telescope_* tools surface to MCP clients (Claude Code, Cursor, etc.)

Every concrete watcher and record type is a final class. The two adapter contracts (TelescopeWatcher, TelescopeHttpAdapter) are abstract class with frozen 3-method signatures (name, install, uninstall). Magic-side glue (MagicHttpFacadeAdapter, MagicModelWatcher, etc.) depends on these contracts; any signature change requires a coordinated bump across both repos.

Compared to

AI Agent Integration

Telescope is the first Flutter MCP server focused on runtime observability (HTTP, exceptions, queries, cache) rather than UI automation. The 9 telescope_* tools give Claude Code, Cursor, Codex, or any MCP-compatible agent direct read access to every runtime buffer: inspect HTTP traffic without a proxy, read logs without grepping output, catch exceptions without scrolling DevTools.

One-line .mcp.json install

telescope:install auto-writes .mcp.json for you. Or wire it manually for any MCP-compatible client:

// .mcp.json (project root) — Claude Code / Codex / Cursor / Goose / VS Code Copilot
{
  "mcpServers": {
    "fluttersdk": {
      "command": "./bin/fsa",
      "args": ["mcp:serve"],
      "cwd": "."
    }
  }
}

After this, restart your MCP client. The 9 telescope_* tools (plus the substrate's artisan_* tools) surface automatically in /mcp.

Before / after

Typical agent session

[agent] artisan_start { device: chrome }          // launch the app
[agent] <exercise the feature under inspection>
[agent] telescope_requests {}                     // inspect all HTTP calls made
[agent] telescope_tail { level: warning }         // filter logs to warnings and above
[agent] telescope_exceptions {}                   // check for any uncaught exceptions
[agent] telescope_queries {}                      // review DB queries and timings
[agent] telescope_clear {}                        // flush buffers before the next scenario
[agent] artisan_stop                              // tear down

For agents that read structured project context at attach time, the canonical entry point is llms.txt at the repo root (also published at https://fluttersdk.com/telescope/llms.txt). It enumerates the watcher surface, the VM extension catalog, and every MCP tool input schema in agent-readable form.

Documentation

Full docs with live examples at fluttersdk.com/telescope.

Contributing

git clone https://github.com/fluttersdk/telescope.git
cd telescope && dart pub get
flutter test && dart analyze

The baseline is 249 tests green (post magic-dev-dep drop). New behavior ships with the matching test (red, green, refactor). dart format lib/ test/ bin/ must produce no diff and dart analyze must report zero issues across lib/, test/, and bin/.

Before opening a pull request, also run:

dart format lib/ test/ bin/         # zero diff
dart analyze                         # zero issues
dart pub publish --dry-run           # validate the publish archive

Report a bug · Request a feature

Inspiration

Telescope is inspired by Laravel Telescope, the elegant developer-tools assistant for Laravel that records every request, exception, log, query, cache hit, and event into a queryable timeline. The same pattern, ported to Flutter, with two additions that make sense for 2026: a CLI-first surface for terminal-native developers and a 9-tool MCP server so AI coding agents can read the timeline directly.

Part of the Magic SDK suite

Telescope is one of seven packages in the FlutterSDK Magic suite, a Laravel-inspired Flutter ecosystem:

• magic — Laravel-style framework (facades, ORM, providers, controllers, routing)
• wind — Tailwind-style className UI primitives for Flutter
• fluttersdk_artisan — Pure Dart CLI + MCP substrate that telescope extends
• fluttersdk_dusk — E2E gesture / snapshot driver via VM extensions
• fluttersdk_telescope (this package) — Runtime observability via VM extensions + MCP
• magic_tinker — Connected REPL into the running app
• magic_starter — Auth / profile / teams scaffolding

License

MIT, see LICENSE for details.

_{Built with care by FlutterSDK
If Telescope saves you debugging time, give it a star, it helps others discover it.}