Files
webstudio/apps/builder/app/shared/sync/data-stores.ts
T
Oleg IsonenandClaude Fable 5 071a4d9a85 feat: MCP update 3 (#5864)
## Summary

This update adds new MCP and CLI capabilities for project auditing,
structured data, project-specific agent instructions, focused project
search, safer bulk editing, image descriptions, font discovery, visual
verification, and external registry inspection.

## New Capabilities

### Audit projects

- Run a single `audit` command across accessibility, SEO, security,
assets, styles, and performance.
- Limit an audit to selected scopes, pages, or severity levels.
- Receive stable findings with locations and suggested fixes.
- Run rendered audits across desktop, mobile, and Builder breakpoint
widths.
- Detect horizontal overflow, broken images, oversized images, eager
below-fold images, render-blocking resources, and legacy font formats.
- Identify unused assets, tokens, CSS variables, local styles, and
breakpoints.
- Identify duplicate token declarations.
- Detect accessibility issues involving names, labels, headings,
landmarks, IDs, keyboard focus, ARIA, iframes, and autoplaying media.
- Detect SEO issues involving titles, descriptions, language, social
images, and structured data.
- Detect unsafe new-tab links and write resources exposed during page
rendering.

### Search an entire project

- Search project text, labels, props, resources, assets, and styles
through `search-project`.
- Find relevant records without downloading and reparsing the full
project snapshot.
- Scope searches to the relevant project-data areas.

### Add validated JSON-LD

- Add structured data with a dedicated JSON-LD component.
- Place JSON-LD inside the page Head Slot.
- Edit JSON in a purpose-built code editor.
- Prevent structurally invalid JSON-LD from being saved.
- Validate Schema.org types, properties, and values.
- Find invalid, missing, unknown, deprecated, or incompatible structured
data through the SEO audit.
- Let agents discover the correct JSON-LD workflow without using page
custom metadata or a generic HTML embed.

### Configure project-specific agent instructions

- Add AI-agent instructions from the new **Agents** section in Project
Settings.
- Synchronize those instructions into a managed root `AGENTS.md`.
- Update or remove the managed file automatically during project sync.
- Protect existing user-owned `AGENTS.md` files from being overwritten.
- Share the instructions with authenticated CLI and MCP agents.
- Keep agent instructions out of publicly readable production bundles.

### Generate and manage image descriptions

- Audit image assets for missing descriptions.
- Let a vision-capable agent inspect each image in its rendered context.
- Save generated descriptions to multiple image assets in one operation.
- Mark images as intentionally decorative.
- Reuse the saved asset description wherever the image is used.
- Re-run the audit to verify that missing-description findings are
resolved.

### Perform bounded bulk replacements

- Replace matching literal text across selected pages with
`replace-text`.
- Replace matching fixed prop text with `replace-prop-text`.
- Replace matching resource names or URLs with `replace-resource-text`.
- Restrict replacements by page, instance, prop, resource, field, match
mode, and maximum change count.
- Leave dynamic expressions unchanged.

### Inspect element ancestry

- Return an element’s direct parent in instance listings.
- Request the complete ancestor chain when inspecting an element.
- Understand tree placement without rebuilding the instance hierarchy
from raw project data.

### Discover available fonts

- List uploaded font families through `list-fonts`.
- Discover available system font stacks.
- Inspect font family, style, weight, format, and associated asset
information before applying typography.

### Inspect external component registries

- Inspect a local or remote shadcn-style registry item.
- Read its description, files, dependencies, targets, and documentation.
- Receive an explicit Webstudio compatibility report.
- Inspect registry metadata without installing or executing external
code.

### Capture generated project routes directly

- Run `webstudio screenshot --path /route` against the configured
project.
- Generate a temporary production-style preview automatically.
- Capture the requested route.
- Stop the temporary preview after capture.
- Avoid manually building and starting a preview for a single
screenshot.

### Assert visual changes

- Add expected text to screenshot comparisons.
- Set maximum pixel mismatch limits.
- Set minimum or maximum changed-region counts.
- Assert whether overall brightness or a color channel moved in the
expected direction.
- Use these assertions as pass/fail evidence for visual changes.

### Require compatible CLI versions

- Send the project-bundle contract version with CLI synchronization
requests.
- Stop incompatible CLI versions before they receive incomplete project
data.
- Tell users exactly how to update the CLI or run the latest version
once.
- Prevent older clients from silently dropping project settings.

## Upgrade Note

This branch introduces a new synchronized project-bundle contract. Older
CLI versions must update before synchronizing against the new API.

```sh
npm install -g webstudio@latest
```

Or run the latest version once:

```sh
npx webstudio@latest <command>
```

---------

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
2026-07-12 11:27:58 +02:00

110 lines
3.1 KiB
TypeScript

/**
* All data stores used by the sync infrastructure.
* This provides a single source of truth for stores used in sync-server and sync-stores.
*/
import { atom } from "nanostores";
import type {
Assets,
Breakpoints,
DataSources,
Instances,
Pages,
Props,
Resource,
Styles,
StyleSources,
StyleSourceSelections,
} from "@webstudio-is/sdk";
import type { Project } from "@webstudio-is/project";
import type {
MarketplaceProduct,
ProjectSettings,
} from "@webstudio-is/project-build";
export const $project = atom<Project | undefined>();
export const $pages = atom<undefined | Pages>(undefined);
export const $assets = atom<Assets>(new Map());
export const $instances = atom<Instances>(new Map());
export const $props = atom<Props>(new Map());
export const $dataSources = atom<DataSources>(new Map());
export const $resources = atom(new Map<Resource["id"], Resource>());
export const $breakpoints = atom<Breakpoints>(new Map());
/**
* styleSources defines where styles come from (local or token).
*
* $styles contains actual styling rules, tied to styleSourceIds.
* $styles.styleSourceId -> $styleSources.id
*/
export const $styleSources = atom<StyleSources>(new Map());
/**
* This is a list of connections between instances (instanceIds) and styleSources.
* $styleSourceSelections.values[] -> $styleSources.id[]
*/
export const $styleSourceSelections = atom<StyleSourceSelections>(new Map());
/**
* $styles contains actual styling rules
* (breakpointId, styleSourceId, property, value, listed), tied to styleSourceIds
* $styles.styleSourceId -> $styleSources.id
*/
export const $styles = atom<Styles>(new Map());
export const $marketplaceProduct = atom<undefined | MarketplaceProduct>();
export const $projectSettings = atom<undefined | ProjectSettings>();
export const $publisherHost = atom<string>("wstd.work");
/**
* Get initial values for all data stores.
* Used for resetting stores when switching between projects.
*/
const getInitialDataStoreValues = () => ({
project: undefined,
pages: undefined,
assets: new Map(),
instances: new Map(),
props: new Map(),
dataSources: new Map(),
resources: new Map(),
breakpoints: new Map(),
styleSources: new Map(),
styleSourceSelections: new Map(),
styles: new Map(),
marketplaceProduct: undefined,
projectSettings: undefined,
publisherHost: "wstd.work",
});
/**
* Reset all data stores to their initial values.
* Call this when switching between projects to prevent data leakage.
*/
export const resetDataStores = () => {
const initial = getInitialDataStoreValues();
$project.set(initial.project);
$pages.set(initial.pages);
$assets.set(initial.assets);
$instances.set(initial.instances);
$props.set(initial.props);
$dataSources.set(initial.dataSources);
$resources.set(initial.resources);
$breakpoints.set(initial.breakpoints);
$styleSources.set(initial.styleSources);
$styleSourceSelections.set(initial.styleSourceSelections);
$styles.set(initial.styles);
$marketplaceProduct.set(initial.marketplaceProduct);
$projectSettings.set(initial.projectSettings);
$publisherHost.set(initial.publisherHost);
};