# PhotoFresco (npm · photofresco)

Let AI agents edit images in a PhotoFresco window you approve: layers, masks, previews and export.

- Trust score: 79/100 (medium)
- Change this week: 0
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-21

## Components

- mcpb · `photofresco-mcp-0.1.2.mcpb`: 56/100, [markdown](https://verifymcp.io/servers/photofresco-photofresco/photofresco-mcp.md), [page](https://verifymcp.io/servers/photofresco-photofresco/photofresco-mcp)
- npm · `photofresco`: 79/100 (this document), [markdown](https://verifymcp.io/servers/photofresco-photofresco/photofresco.md), [page](https://verifymcp.io/servers/photofresco-photofresco/photofresco)

## Channel facts

- Registry: `npm`
- Package: `photofresco`
- Version: `0.1.2`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-21.

- **Supply Chain Security**: 100/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - No production dependencies, so there is no dependency health to assess.
- **Provenance & Transparency**: 97/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to photofresco/photofresco-agent).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 14 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 63/100
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 7558 tokens (~198/item across 38 items; 38 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 2 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 39 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### How do I install the PhotoFresco MCP server?

PhotoFresco runs locally as an npm package, launched with npx -y photofresco mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add photofresco-photofresco -- npx -y photofresco mcp
```

### Cursor

```json
{
  "mcpServers": {
    "photofresco-photofresco": {
      "command": "npx",
      "args": [
        "-y",
        "photofresco",
        "mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "photofresco-photofresco": {
      "command": "npx",
      "args": [
        "-y",
        "photofresco",
        "mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add photofresco-photofresco -- npx -y photofresco mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "photofresco-photofresco": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "photofresco",
        "mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add photofresco-photofresco --command npx --arg -y --arg photofresco --arg mcp
```

### Hermes

```yaml
mcp_servers:
  photofresco-photofresco:
    command: "npx"
    args: ["-y", "photofresco", "mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "photofresco-photofresco": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "photofresco",
        "mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add photofresco-photofresco -t stdio -c npx -a -y photofresco mcp
```

### Other

```json
{
  "mcpServers": {
    "photofresco-photofresco": {
      "command": "npx",
      "args": [
        "-y",
        "photofresco",
        "mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-10 (score 79, +5)

- [security improvement] Source repository: unverified → pass

### 2026-11-09 (score 74, −5)

- [security regression] Provenance: pass → unverified

### 2026-11-07 (score 79)

First indexed and scored.

## MCP tools (38)

### `photofresco_connect` (~286 tokens)

Connect to PhotoFresco

Open PhotoFresco in its own browser window on this computer and ask the user to allow this agent. The window shows a connection code; tell the user the code returned here so they can check it before clicking Allow.
Inputs: access (optional) asks for permissions right away; document is "active" (default), "none" or a document_id; wait_seconds (default 40, at most 170) is how long this call waits for the user.
Returns state "connected" with the session status, or state "pairing" with the code while the user has not decided yet: call photofresco_connect again to keep waiting (the request expires after 3 minutes). A session starts with no permissions; the editing tools appear (tools/list_changed) once the user grants them in the Permissions dialog.
Effect: starts a browser process and loads photofresco.com on the first call; nothing is edited. Safe to call again while connected (returns the current status).

Input parameters:

- `access` (object): Permissions to ask the user for once connected. Asking grants nothing; the user decides in the PhotoFresco window
- `document` (string): "active" (default), "none", or a document_id from photofresco_documents
- `wait_seconds` (number): Seconds to wait for the user's decision before returning the pending code (default 40)

### `photofresco_status` (~66 tokens)

PhotoFresco status

Connection state, the pending connection code, the session (target document_id, revision, granted permissions, pending permission request, credit budget, pause state), folders granted for import/export and the enabled tool groups.
Inputs: none. Effect: reads state only; never starts a browser.

### `photofresco_request_access` (~211 tokens)

Ask the user for permissions

Ask the user for permissions in the PhotoFresco window (replaces any pending request). The user may grant fewer; nothing is granted until they click Allow there. Tools appear as permissions arrive (tools/list_changed); photofresco_status shows grants and the pending request.
Inputs: capabilities (required), budget_credits (required with spend, 1–100000 credits), reason (shown to the user, at most 200 characters).
Effect: shows a request in the editor; changes no document. Needs a connected session.

Input parameters:

- `budget_credits` (integer): Credit budget for paid AI (required with spend)
- `capabilities` (array, required): Permissions to ask for: read (see the document and previews), edit (change documents, open/close tabs), export (files leave the editor), external-write (send data to PhotoFresco services), spend (pai…
- `reason` (string): Why, shown to the user (at most 200 characters)

### `photofresco_documents` (~58 tokens)

List open documents

Open documents in the PhotoFresco window: document_id, name, whether it is the active tab, revision, which agent controls it and whether it is paused. Inputs: none. Effect: reads state only. Needs a connected session.

### `photofresco_attach` (~81 tokens)

Target a document

Make this session target another open document by document_id (from photofresco_documents). Operations run only while the target is the active tab, so ask the user to switch tabs if needed. Inputs: document (required). Effect: changes the session target; no document edit. Needs a connected session.

Input parameters:

- `document` (string, required): document_id to target

### `photofresco_disconnect` (~93 tokens)

Disconnect from PhotoFresco

End this session (same as the user pressing Stop): in-flight work is interrupted, permissions are cleared, applied edits stay in History. The window stays open for the user unless close_window is true. Reconnecting needs the user's Allow again. Inputs: close_window (optional). Effect: ends the session; edits nothing.

Input parameters:

- `close_window` (boolean): Also close the PhotoFresco browser window this server opened

### `photofresco_list_tool_groups` (~45 tokens)

List PhotoFresco tool groups

The op groups this server can list as tools, which are enabled, and how many tools each adds now. Inputs: none. Effect: reads server state only.

### `photofresco_select_tool_groups` (~100 tokens)

Enable or disable tool groups

Enable or disable op groups to change which PhotoFresco operations are listed as tools (sends tools/list_changed). Use it when a needed operation is not listed. Listing never grants permissions. Inputs: enable, disable (group IDs from photofresco_list_tool_groups, or "all"). Effect: changes this server's tool list only.

Input parameters:

- `disable` (array): Groups to remove
- `enable` (array): Groups to add

### `adjust_add` (~315 tokens)

Adjustment: Add

Add a non-destructive adjustment layer above the active node. Types include brightness-contrast, levels, curves, exposure, hue-saturation, vibrance, color-balance, black-white, photo-filter, channel-mixer, gradient-map, selective-color, color-lookup, shadows-highlights, match-replace-color, invert, posterize, and threshold. Pass type-specific params in "params". Match color accepts source_layer_id/target_layer_id to sample RGB statistics. Set clipped=true (layer.set_props) to affect only the layer below.

Inputs: adjustment_type (required), params. Units, ranges and allowed values are in the input schema; the editor rejects arguments outside it before anything runs.
Effect: Edits the document through an undoable command that appears in History.
Undo: history_undo reverts it.
Permission: Edit, granted by the user in the PhotoFresco window (ask with photofresco_request_access).
Returns immediately with the result.
Results carry document_id and revision. PhotoFresco operation: adjust.add.

Input parameters:

- `adjustment_type` (string, required): Which adjustment
- `params` (object): Adjustment parameter patch. Choose the branch matching adjustment_type for adjust.add, or the existing adjustment type for adjust.set_params; type may be omitted. Only supplied top-level fields chang…

### `adjust_set_params` (~211 tokens)

Adjustment: Set params

Update the active adjustment layer’s parameters (same shapes as adjust.add). Undoable.

Inputs: params (required). Units, ranges and allowed values are in the input schema; the editor rejects arguments outside it before anything runs.
Effect: Edits the document through an undoable command that appears in History.
Undo: history_undo reverts it.
Permission: Edit, granted by the user in the PhotoFresco window (ask with photofresco_request_access).
Returns immediately with the result.
Results carry document_id and revision. PhotoFresco operation: adjust.set_params.

Input parameters:

- `params` (object, required): Adjustment parameter patch. Choose the branch matching adjustment_type for adjust.add, or the existing adjustment type for adjust.set_params; type may be omitted. Only supplied top-level fields chang…

### `canvas_resize` (~200 tokens)

Canvas: Resize

Change canvas size without resampling; content shifts by (dx, dy) px (e.g. dx=(newW−oldW)/2 to center). Clears the selection. Undoable.

Inputs: width (required), height (required), dx, dy. Units, ranges and allowed values are in the input schema; the editor rejects arguments outside it before anything runs.
Effect: Edits the document through an undoable command that appears in History.
Undo: history_undo reverts it.
Permission: Edit, granted by the user in the PhotoFresco window (ask with photofresco_request_access).
Returns immediately with the result.
Results carry document_id and revision. PhotoFresco operation: canvas.resize.

Input parameters:

- `dx` (number): Content shift x (default 0)
- `dy` (number): Content shift y (default 0)
- `height` (number, required): New height px
- `width` (number, required): New width px

### `crop_apply` (~156 tokens)

Crop: Apply

Apply pending crop or set a rectangle then apply. Undoable.

Inputs: x, y, width, height. Units, ranges and allowed values are in the input schema; the editor rejects arguments outside it before anything runs.
Effect: Edits the document through an undoable command that appears in History.
Undo: history_undo reverts it.
Permission: Edit, granted by the user in the PhotoFresco window (ask with photofresco_request_access).
Returns immediately with the result.
Results carry document_id and revision. PhotoFresco operation: crop.apply.

Input parameters:

- `height` (number): Height
- `width` (number): Width
- `x` (number): Document x
- `y` (number): Document y

### `doc_get_state` (~130 tokens)

Document: Get state

Get the full document state: document_id and content revision (agent sessions), dimensions, color mode, the layer tree (ids, names, kinds, blend modes, opacity, visibility, locks, pixel bounds), the active node id, and the current selection bounds. Call this first to orient yourself.

Inputs: none.
Effect: Reads the document or editor state; changes nothing.
Permission: Read, granted by the user in the PhotoFresco window (ask with photofresco_request_access).
Returns immediately with the result.
Results carry document_id and revision. PhotoFresco operation: doc.get_state.

### `doc_histogram` (~148 tokens)

Document: Histogram

Return 256-bin histogram counts for the flattened visible document, restricted to the active selection when one exists. mode defaults to luminosity; rgb returns composite plus red/green/blue counts.

Inputs: mode. Units, ranges and allowed values are in the input schema; the editor rejects arguments outside it before anything runs.
Effect: Reads the document or editor state; changes nothing.
Permission: Read, granted by the user in the PhotoFresco window (ask with photofresco_request_access).
Returns immediately with the result.
Results carry document_id and revision. PhotoFresco operation: doc.histogram.

Input parameters:

- `mode` (string): rgb, red, green, blue, or luminosity

### `doc_new` (~253 tokens)

Document: New

Create a new document tab. Width/height use unit (px, in, cm, mm) and resolution; background is white, transparent, or color.

Inputs: name, width, height, unit, resolution, background, background_color, preset. Units, ranges and allowed values are in the input schema; the editor rejects arguments outside it before anything runs.
Effect: Opens, closes, duplicates or reverts documents (tabs); history_undo does not reverse it.
Undo: not reversible with history_undo.
Permission: Edit, granted by the user in the PhotoFresco window (ask with photofresco_request_access).
Returns immediately with the result.
Results carry document_id and revision. PhotoFresco operation: doc.new.

Input parameters:

- `background` (string): Background contents
- `background_color` (array): [r,g,b] when background=color
- `height` (number): Height in the selected unit
- `name` (string): Document name (default Untitled)
- `preset` (string): Preset id for UI bookkeeping
- `resolution` (number): Pixels per inch for physical units
- `unit` (string): Measurement unit
- `width` (number): Width in the selected unit

### `doc_sample_color` (~146 tokens)

Document: Sample color

Read the flattened composite color at document coordinate (x, y). Returns RGB, RGBA, and HSB; does not change the foreground color.

Inputs: x (required), y (required). Units, ranges and allowed values are in the input schema; the editor rejects arguments outside it before anything runs.
Effect: Reads the document or editor state; changes nothing.
Permission: Read, granted by the user in the PhotoFresco window (ask with photofresco_request_access).
Returns immediately with the result.
Results carry document_id and revision. PhotoFresco operation: doc.sample_color.

Input parameters:

- `x` (number, required): Doc x
- `y` (number, required): Doc y

### `edit_fill` (~239 tokens)

Edit: Fill

Fill the selection (or the whole canvas if none) on the active layer. Default contents=color uses color [r,g,b] or the current foreground; contents=pattern uses the active pattern or pattern_id.

Inputs: contents, color, pattern_id, blend_mode, opacity. Units, ranges and allowed values are in the input schema; the editor rejects arguments outside it before anything runs.
Effect: Edits the document through an undoable command that appears in History.
Undo: history_undo reverts it.
Permission: Edit, granted by the user in the PhotoFresco window (ask with photofresco_request_access).
Returns immediately with the result.
Results carry document_id and revision. PhotoFresco operation: edit.fill.

Input parameters:

- `blend_mode` (string): Pattern blend mode (default normal)
- `color` (array): [r, g, b] each 0-255
- `contents` (string): color (default) or pattern
- `opacity` (number): Pattern opacity 0..1 (default 1)
- `pattern_id` (string): Pattern preset id; defaults to the active pattern when contents=pattern

### `export_artifact` (~391 tokens)

Export: Artifact

Export the active document and keep the file in the editor as a retrievable artifact instead of starting a browser download. format "png" is the flattened visible composite (or, with layer_id, that layer's own pixels at its content bounds); "psd" is the layered Photoshop interchange file from File > Save; "pfd" is PhotoFresco's native editable document from Save to My Documents. Returns { artifact_id, format, mime_type, filename, byte_length, sha256, document_id, revision, width, height, layer_id, fidelity, loss, created_at, expires_at }; read the bytes with artifact.read. Artifacts are bound to this caller and document, kept 10 minutes, at most 256.0 MiB each and 16 per caller (the oldest is evicted). Errors: export_failed, export_timeout (120 s), artifact_too_large, artifact_limit, stale_revision (the document changed during the export). Nothing is written to disk.

The result links an MCP resource (photofresco://artifact/<id>) holding the bytes; photofresco_export_file writes the export to a granted folder in one step.
Inputs: format (required), layer_id. Units, ranges and allowed values are in the input schema; the editor rejects arguments outside it before anything runs.
Effect: Reads the document or editor state; changes nothing.
Permission: Read + Export, granted by the user in the PhotoFresco window (ask with photofresco_request_access).
Returns when the operation has finished (it may take seconds).
Results carry document_id and revision. PhotoFresco operation: export.artifact.

Input parameters:

- `format` (string, required): png (flattened or one layer), psd (layered interchange) or pfd (native, full fidelity)
- `layer_id` (string): PNG only: export this layer's own pixels instead of the composite

### `filter_apply` (~477 tokens)

Filter: Apply

Apply a destructive filter to the active layer (selection restricts it). Types: gaussian-blur {radius px}, sharpen {amount 0..3, radius px}, sharpen-more, sharpen-edges, unsharp-mask {amount percent 1..500, radius px, threshold 0..255}, noise {amount 0..1}, box-blur {radius px}, motion-blur {angle deg, distance px}, radial-blur {amount 1..100, method spin|zoom}, average, median {radius 1..8}, mosaic {cellSize px}, high-pass {radius px}, ripple {amount px, wavelength px}, twirl {angle deg}, spherize {amount -100..100}, wave {amplitude px, wavelength px}, zigzag {amount px, ridges}, polar-coordinates {mode rect-to-polar|polar-to-rect}, crystallize {cellSize px}, pointillize {cellSize px}, facet, fragment, despeckle, dust-and-scratches {radius px, threshold 0..255}, emboss {angle deg, height px, amount 0..5}, find-edges, solarize, trace-contour {level 0..255, edge lower|upper}, wind {method wind|blast|stagger, direction left|right}, clouds, difference-clouds, lens-flare {brightness percent 10..300, centerX 0..1, centerY 0..1}, fibers {variance 1..64, strength 1..64}, maximum {radius px}, minimum {radius px}, offset {dx px, dy px}, custom {kernel 25 numbers, scale, offset}. Pass params in "params".

Inputs: filter_type (required), params. Units, ranges and allowed values are in the input schema; the editor rejects arguments outside it before anything runs.
Effect: Edits the document through an undoable command that appears in History.
Undo: history_undo reverts it.
Permission: Edit, granted by the user in the PhotoFresco window (ask with photofresco_request_access).
Returns immediately with the result.
Results carry document_id and revision. PhotoFresco operation: filter.apply.

Input parameters:

- `filter_type` (string, required): Which filter
- `params` (object): Type-specific parameters

### `history_redo` (~92 tokens)

History: Redo

Redo the next edit. Returns the label of what was redone, or null.

Inputs: none.
Effect: Edits the document through an undoable command that appears in History.
Permission: Edit, granted by the user in the PhotoFresco window (ask with photofresco_request_access).
Returns immediately with the result.
Results carry document_id and revision. PhotoFresco operation: history.redo.

### `history_undo` (~103 tokens)

History: Undo

Undo the last edit. Returns the label of what was undone, or null.

Reverts the last History entry, including edits made by the user.
Inputs: none.
Effect: Edits the document through an undoable command that appears in History.
Permission: Edit, granted by the user in the PhotoFresco window (ask with photofresco_request_access).
Returns immediately with the result.
Results carry document_id and revision. PhotoFresco operation: history.undo.

### `image_resize` (~145 tokens)

Image: Resize

Resample the whole document to new pixel dimensions (bilinear). Undoable.

Inputs: width (required), height (required). Units, ranges and allowed values are in the input schema; the editor rejects arguments outside it before anything runs.
Effect: Edits the document through an undoable command that appears in History.
Undo: history_undo reverts it.
Permission: Edit, granted by the user in the PhotoFresco window (ask with photofresco_request_access).
Returns immediately with the result.
Results carry document_id and revision. PhotoFresco operation: image.resize.

Input parameters:

- `height` (number, required): New height px
- `width` (number, required): New width px

### `image_rotate` (~158 tokens)

Image: Rotate

Rotate the whole canvas by quarter turns: 1 = 90° clockwise, 2 = 180°, 3 = 90° counter-clockwise. Undoable.

Inputs: turns (required). Units, ranges and allowed values are in the input schema; the editor rejects arguments outside it before anything runs.
Effect: Edits the document through an undoable command that appears in History.
Undo: history_undo reverts it.
Permission: Edit, granted by the user in the PhotoFresco window (ask with photofresco_request_access).
Returns immediately with the result.
Results carry document_id and revision. PhotoFresco operation: image.rotate.

Input parameters:

- `turns` (number, required): 1, 2, or 3 quarter turns

### `layer_add` (~131 tokens)

Layer: Add

Add a new empty layer above the active node and make it active.

Inputs: name. Units, ranges and allowed values are in the input schema; the editor rejects arguments outside it before anything runs.
Effect: Edits the document through an undoable command that appears in History.
Undo: history_undo reverts it.
Permission: Edit, granted by the user in the PhotoFresco window (ask with photofresco_request_access).
Returns immediately with the result.
Results carry document_id and revision. PhotoFresco operation: layer.add.

Input parameters:

- `name` (string): Layer name (default "Layer N")

### `layer_delete` (~95 tokens)

Layer: Delete

Delete the active node. Refused if it would leave no layers.

Inputs: none.
Effect: Edits the document through an undoable command that appears in History.
Undo: history_undo reverts it.
Permission: Edit, granted by the user in the PhotoFresco window (ask with photofresco_request_access).
Returns immediately with the result.
Results carry document_id and revision. PhotoFresco operation: layer.delete.

### `layer_duplicate` (~96 tokens)

Layer: Duplicate

Duplicate the active node (deep for groups); the copy becomes active.

Inputs: none.
Effect: Edits the document through an undoable command that appears in History.
Undo: history_undo reverts it.
Permission: Edit, granted by the user in the PhotoFresco window (ask with photofresco_request_access).
Returns immediately with the result.
Results carry document_id and revision. PhotoFresco operation: layer.duplicate.

### `layer_set_active` (~129 tokens)

Layer: Set active

Set the active node (layers paint/transform; groups move as a unit).

Inputs: id (required). Units, ranges and allowed values are in the input schema; the editor rejects arguments outside it before anything runs.
Effect: Changes editor view or tool settings; not a document edit and not in History.
Permission: Edit, granted by the user in the PhotoFresco window (ask with photofresco_request_access).
Returns immediately with the result.
Results carry document_id and revision. PhotoFresco operation: layer.set_active.

Input parameters:

- `id` (string, required): Node id from doc.get_state

### `layer_set_props` (~484 tokens)

Layer: Set props

Set properties on a node (default: the active one). Only provided fields change. blend_mode "pass-through" is groups-only.

Inputs: id, name, visible, opacity, blend_mode, locked, lock_pixels, lock_position, lock_transparency, clipped, blend_if, channel_mask, knockout, blend_interior_as_group, blend_clipped_as_group, transparency_shapes_layer, mask_hides_effects, vector_mask_hides_effects. Units, ranges and allowed values are in the input schema; the editor rejects arguments outside it before anything runs.
Effect: Edits the document through an undoable command that appears in History.
Undo: history_undo reverts it.
Permission: Edit, granted by the user in the PhotoFresco window (ask with photofresco_request_access).
Returns immediately with the result.
Results carry document_id and revision. PhotoFresco operation: layer.set_props.

Input parameters:

- `blend_clipped_as_group` (boolean): Apply the clipping base blend/opacity to the whole clip unit
- `blend_if` (object|null): Raster layer Blend If {channel,thisLayer:[b0,b1,w1,w0],underlying:[...]}; null clears it
- `blend_interior_as_group` (boolean): Blend fill and interior effects as one source
- `blend_mode` (string): Blend mode
- `channel_mask` (object): Raster layer RGB write mask {r:boolean,g:boolean,b:boolean}
- `clipped` (boolean): Clipping mask: confine rendering to the alpha of the layer below (⌥⌘G)
- `id` (string): Target node id (default: active)
- `knockout` (string): Knockout depth
- `lock_pixels` (boolean): Raster layer pixel lock
- `lock_position` (boolean): Raster layer position lock
- `lock_transparency` (boolean): Raster layer transparency lock
- `locked` (boolean): Lock/unlock
- `mask_hides_effects` (boolean): Apply the raster layer mask to generated effect output
- `name` (string): Rename
- `opacity` (number): 0..1
- `transparency_shapes_layer` (boolean): Use source transparency to shape fill and interior effects
- `vector_mask_hides_effects` (boolean): Apply the vector mask to generated effect output
- `visible` (boolean): Show/hide

### `mask_add` (~149 tokens)

Mask: Add

Add a raster mask to the active layer. mode "selection" rasterizes the current selection (selected = visible); default is "selection" when one exists, else "reveal".

Inputs: mode. Units, ranges and allowed values are in the input schema; the editor rejects arguments outside it before anything runs.
Effect: Edits the document through an undoable command that appears in History.
Undo: history_undo reverts it.
Permission: Edit, granted by the user in the PhotoFresco window (ask with photofresco_request_access).
Returns immediately with the result.
Results carry document_id and revision. PhotoFresco operation: mask.add.

Input parameters:

- `mode` (string): Mask contents

### `mask_remove` (~95 tokens)

Mask: Remove

Delete the active layer’s mask (the layer becomes fully visible again).

Inputs: none.
Effect: Edits the document through an undoable command that appears in History.
Undo: history_undo reverts it.
Permission: Edit, granted by the user in the PhotoFresco window (ask with photofresco_request_access).
Returns immediately with the result.
Results carry document_id and revision. PhotoFresco operation: mask.remove.

### `render_mask` (~611 tokens)

Preview: Mask

Preview a mask over a document-space region as a grayscale PNG (black 0 = hidden/unselected, white 255 = shown/selected) with exact coverage statistics { pixels, nonzero, full, mean } computed at document resolution over the region. source "layer" (default) is a layer's raster mask (layer_id, default the active layer), placed at its document position; source "selection" is the current selection. Read-only. Returns image { mime_type: "image/png", data_base64, width, height, byte_length } plus document_id, revision (the document revision rendered), document { width, height }, requested and region { x, y, width, height } (region = requested clipped to the canvas; clipped: true when they differ), scale { x, y } and the coordinate convention. Errors carry code: invalid_region, region_out_of_bounds, preview_too_large, unknown_layer, unsupported_layer_kind, mask_unavailable, stale_revision (the document changed while rendering). Limits: output ≤ 2048 px per side and 4194304 px, PNG ≤ 8.0 MiB; the source is read in strips of ≤ 8.0 MiB so a small region of a huge document stays small.

Inputs: x, y, width, height, max_size, scale, source, layer_id. Units, ranges and allowed values are in the input schema; the editor rejects arguments outside it before anything runs.
Effect: Reads the document or editor state; changes nothing.
Permission: Read, granted by the user in the PhotoFresco window (ask with photofresco_request_access).
Returns when the operation has finished (it may take seconds).
Results carry document_id and revision. PhotoFresco operation: render.mask.

Input parameters:

- `height` (number): Region height in document pixels (whole number; default: to the bottom canvas edge)
- `layer_id` (string): Layer whose raster mask to show (source layer; default the active layer)
- `max_size` (number): Fit the preview inside this many pixels per side, never magnifying (default 1024). Use scale instead for exact detail
- `scale` (number): Exact output pixels per document pixel (1 = actual pixels, 4 = 4× magnified with nearest sampling, 0.25 = area-averaged). Output is limited to 2048 px per side and 4194304 px
- `source` (string): layer: the raster mask of layer_id (default); selection: the active selection
- `width` (number): Region width in document pixels (whole number; default: to the right canvas edge)
- `x` (number): Left edge in document pixels (whole number, default 0). May be negative; the region is clipped to the canvas
- `y` (number): Top edge in document pixels (whole number, default 0). May be negative; the region is clipped to the canvas

### `render_preview` (~168 tokens)

Preview: Preview

Render the whole flattened composite to a PNG data URL, downscaled to fit max_size (never magnified). Use after edits to see the result. For a region at detail scale, one layer, a mask, or coordinate metadata use render.region / render.mask.

Inputs: max_size. Units, ranges and allowed values are in the input schema; the editor rejects arguments outside it before anything runs.
Effect: Reads the document or editor state; changes nothing.
Permission: Read, granted by the user in the PhotoFresco window (ask with photofresco_request_access).
Returns immediately with the result.
Results carry document_id and revision. PhotoFresco operation: render.preview.

Input parameters:

- `max_size` (number): Max width/height in px (default 512, at most 2048)

### `render_region` (~598 tokens)

Preview: Region

Preview a document-space region at a chosen scale as a PNG, without rendering the whole document. Without layer_id it shows the flattened visible composite (same compositor as PNG export); with layer_id it shows that layer's own pixels (raster, text, shape or smart object) before its mask, opacity, blend mode and effects. Use scale 1–16 to inspect detail at actual or magnified pixels, or max_size to fit an overview. Read-only; nothing is added to history. Returns image { mime_type: "image/png", data_base64, width, height, byte_length } plus document_id, revision (the document revision rendered), document { width, height }, requested and region { x, y, width, height } (region = requested clipped to the canvas; clipped: true when they differ), scale { x, y } and the coordinate convention. Errors carry code: invalid_region, region_out_of_bounds, preview_too_large, unknown_layer, unsupported_layer_kind, mask_unavailable, stale_revision (the document changed while rendering). Limits: output ≤ 2048 px per side and 4194304 px, PNG ≤ 8.0 MiB; the source is read in strips of ≤ 8.0 MiB so a small region of a huge document stays small.

Inputs: x, y, width, height, max_size, scale, layer_id. Units, ranges and allowed values are in the input schema; the editor rejects arguments outside it before anything runs.
Effect: Reads the document or editor state; changes nothing.
Permission: Read, granted by the user in the PhotoFresco window (ask with photofresco_request_access).
Returns when the operation has finished (it may take seconds).
Results carry document_id and revision. PhotoFresco operation: render.region.

Input parameters:

- `height` (number): Region height in document pixels (whole number; default: to the bottom canvas edge)
- `layer_id` (string): Optional layer id (doc.get_state) to preview that layer alone instead of the composite
- `max_size` (number): Fit the preview inside this many pixels per side, never magnifying (default 1024). Use scale instead for exact detail
- `scale` (number): Exact output pixels per document pixel (1 = actual pixels, 4 = 4× magnified with nearest sampling, 0.25 = area-averaged). Output is limited to 2048 px per side and 4194304 px
- `width` (number): Region width in document pixels (whole number; default: to the right canvas edge)
- `x` (number): Left edge in document pixels (whole number, default 0). May be negative; the region is clipped to the canvas
- `y` (number): Top edge in document pixels (whole number, default 0). May be negative; the region is clipped to the canvas

### `selection_all` (~86 tokens)

Selection: All

Select the whole document.

Inputs: none.
Effect: Edits the document through an undoable command that appears in History.
Undo: history_undo reverts it.
Permission: Edit, granted by the user in the PhotoFresco window (ask with photofresco_request_access).
Returns immediately with the result.
Results carry document_id and revision. PhotoFresco operation: selection.all.

### `selection_ellipse` (~198 tokens)

Selection: Ellipse

Select an ellipse inscribed in the given rect (doc coordinates).

Inputs: x (required), y (required), w (required), h (required), mode, feather. Units, ranges and allowed values are in the input schema; the editor rejects arguments outside it before anything runs.
Effect: Edits the document through an undoable command that appears in History.
Undo: history_undo reverts it.
Permission: Edit, granted by the user in the PhotoFresco window (ask with photofresco_request_access).
Returns immediately with the result.
Results carry document_id and revision. PhotoFresco operation: selection.ellipse.

Input parameters:

- `feather` (number): Feather radius in px (softens the edge)
- `h` (number, required): Height
- `mode` (string): How to combine with the existing selection
- `w` (number, required): Width
- `x` (number, required): Left
- `y` (number, required): Top

### `selection_invert` (~89 tokens)

Selection: Invert

Invert the current selection.

Inputs: none.
Effect: Edits the document through an undoable command that appears in History.
Undo: history_undo reverts it.
Permission: Edit, granted by the user in the PhotoFresco window (ask with photofresco_request_access).
Returns immediately with the result.
Results carry document_id and revision. PhotoFresco operation: selection.invert.

### `selection_none` (~95 tokens)

Selection: None

Deselect — clear the selection so edits affect the whole canvas again.

Inputs: none.
Effect: Edits the document through an undoable command that appears in History.
Undo: history_undo reverts it.
Permission: Edit, granted by the user in the PhotoFresco window (ask with photofresco_request_access).
Returns immediately with the result.
Results carry document_id and revision. PhotoFresco operation: selection.none.

### `selection_rect` (~190 tokens)

Selection: Rect

Select a rectangle in doc coordinates.

Inputs: x (required), y (required), w (required), h (required), mode, feather. Units, ranges and allowed values are in the input schema; the editor rejects arguments outside it before anything runs.
Effect: Edits the document through an undoable command that appears in History.
Undo: history_undo reverts it.
Permission: Edit, granted by the user in the PhotoFresco window (ask with photofresco_request_access).
Returns immediately with the result.
Results carry document_id and revision. PhotoFresco operation: selection.rect.

Input parameters:

- `feather` (number): Feather radius in px (softens the edge)
- `h` (number, required): Height
- `mode` (string): How to combine with the existing selection
- `w` (number, required): Width
- `x` (number, required): Left
- `y` (number, required): Top

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/photofresco-photofresco/photofresco#diagnostics

## Score history

- 2026-11-21: 79
- 2026-11-20: 79
- 2026-11-19: 79
- 2026-11-18: 79
- 2026-11-17: 79
- 2026-11-16: 79
- 2026-11-15: 79
- 2026-11-14: 79
- 2026-11-13: 79
- 2026-11-12: 79
- 2026-11-11: 79
- 2026-11-10: 79
- 2026-11-09: 74
- 2026-11-08: 79
- 2026-11-07: 79

## Common questions

### What is the PhotoFresco MCP server?

PhotoFresco is an MCP server listed in the public MCP registry as io.github.photofresco/photofresco. Let AI agents edit images in a PhotoFresco window you approve: layers, masks, previews and export. This page covers its npm package (photofresco).

### Is the PhotoFresco MCP server safe to use?

PhotoFresco scores 79 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 21 November 2026. It declares no install or post-install scripts. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the PhotoFresco MCP server expose?

PhotoFresco exposes 38 tools: photofresco_connect, photofresco_status, photofresco_request_access, photofresco_documents, photofresco_attach, and 33 more. Their descriptions and schemas cost roughly 7,318 tokens of context every time the server is loaded.

### Is the PhotoFresco MCP server still maintained?

PhotoFresco is still listed as active in the MCP registry. We last reached this channel on 21 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the PhotoFresco MCP server under?

PhotoFresco declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

### What did VerifyMCP test on the PhotoFresco MCP server?

VerifyMCP ran 15 checks on PhotoFresco, covering Malware scan, Known CVEs, Install scripts, Dependency health and 11 more. One item could not be completed, a gap on our side rather than a finding about PhotoFresco: Stability. One category scores 0 for that reason, because we only credit what we can confirm. Endpoint Security and Transport & Reachability do not apply to an npm package, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- npm package: https://www.npmjs.com/package/photofresco
- Socket report: https://socket.dev/npm/package/photofresco
- Repository: https://github.com/photofresco/photofresco-agent
- Website: https://photofresco.com/?pf_ref=mcp-registry
- Changelog RSS feed: https://verifymcp.io/servers/photofresco-photofresco/photofresco.xml
- Changelog JSON feed: https://verifymcp.io/servers/photofresco-photofresco/photofresco/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/photofresco-photofresco/photofresco.json
- HTML version of this page: https://verifymcp.io/servers/photofresco-photofresco/photofresco
