# PixInsight Connector (npm · pixinsight-connector)

Operate PixInsight from any MCP agent. Community project, not affiliated with Pleiades Astrophoto

- Trust score: 88/100 (high trust)
- Change this week: +5
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-10-16

## Components

- npm · `pixinsight-connector`: 88/100 (this document), [markdown](https://verifymcp.io/servers/mxcoppell-pixinsight-connector/pixinsight-connector.md), [page](https://verifymcp.io/servers/mxcoppell-pixinsight-connector/pixinsight-connector)

## Channel facts

- Registry: `npm`
- Package: `pixinsight-connector`
- Version: `2.5.0`
- 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-10-16.

- **Supply Chain Security**: 98/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.
  - 31 of 92 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 100/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to mxcoppell/pixinsight-connector).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 15 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 67/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 17706 tokens (~194/item across 91 items; 91 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 73/100
  - Stability observed for 22 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **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**: 75/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - 0 of 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "remove_mask" implies "remove" and declares no destructiveHint at all, which the MCP spec reads as destructive by default.
  - An AI judge read all 92 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the PixInsight Connector MCP server?

PixInsight Connector runs locally as an npm package, launched with npx -y pixinsight-connector. 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 mxcoppell-pixinsight-connector -- npx -y pixinsight-connector
```

### Cursor

```json
{
  "mcpServers": {
    "mxcoppell-pixinsight-connector": {
      "command": "npx",
      "args": [
        "-y",
        "pixinsight-connector"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "mxcoppell-pixinsight-connector": {
      "command": "npx",
      "args": [
        "-y",
        "pixinsight-connector"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add mxcoppell-pixinsight-connector -- npx -y pixinsight-connector
```

### opencode

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

### OpenClaw

```bash
openclaw mcp add mxcoppell-pixinsight-connector --command npx --arg -y --arg pixinsight-connector
```

### Hermes

```yaml
mcp_servers:
  mxcoppell-pixinsight-connector:
    command: "npx"
    args: ["-y", "pixinsight-connector"]
```

### Netclaw

```json
{
  "McpServers": {
    "mxcoppell-pixinsight-connector": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "pixinsight-connector"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add mxcoppell-pixinsight-connector -t stdio -c npx -a -y pixinsight-connector
```

### Other

```json
{
  "mcpServers": {
    "mxcoppell-pixinsight-connector": {
      "command": "npx",
      "args": [
        "-y",
        "pixinsight-connector"
      ]
    }
  }
}
```

## 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-10-15 (score 88, +1)

No change was recorded against any check on this day. Stability & Change Management went from 67 to 70. That category is still filling its 30-day observation window: 20 days of observed history at the previous scan, 21 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-13 (score 87, +1)

No change was recorded against any check on this day. Stability & Change Management went from 60 to 63. That category is still filling its 30-day observation window: 18 days of observed history at the previous scan, 19 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-11 (score 86, +3)

No change was recorded against any check on this day. Stability & Change Management went from 33 to 57. That category is still filling its 30-day observation window: 10 days of observed history at the previous scan, 17 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-04 (score 83, +1)

No change was recorded against any check on this day. Stability & Change Management went from 30 to 33. That category is still filling its 30-day observation window: 9 days of observed history at the previous scan, 10 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-02 (score 82, +1)

No change was recorded against any check on this day. Stability & Change Management went from 23 to 27. That category is still filling its 30-day observation window: 7 days of observed history at the previous scan, 8 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-01 (score 81, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-09-30 (score 66, −15)

- [security regression] Known CVEs: pass → unverified
- [security regression] Malware scan: pass → unverified
- [functional regression] Dependency health: 0.84 → unverified
- [functional] Package version: 2.3.0 → 2.5.0
- [functional] Package version: 2.3.0 → 2.4.1
- [functional] Package version: 2.3.0 → 2.4.0

### 2026-09-29 (score 81, +16)

- [security improvement] Malware scan: unverified → pass

## MCP tools (91)

### `align_files` (~360 tokens)

Register image files onto a reference image file with StarAlignment, file to file (no views are opened). Targets run in batches of at most batch_size (20 at most), one StarAlignment execution per batch. Registered files (<name><output_postfix>.xisf) go to output_dir, which must lie inside <workspace>/output (a relative path is resolved there) or the state folder. matrix_only: StarAlignment in OutputMatrix mode, reporting the registration per target without keeping any image file; its output directory is a temporary folder under <workspace>/agentic/scratch/align_files that is deleted afterwards, and any file written there is listed. Per target the result gives the outputData values StarAlignment reports (output file, star pair matches, errors, transformation elements, as this PixInsight names them). Runs without geometry confirmation dialogs.

Input parameters:

- `batch_size` (integer): Targets per StarAlignment execution, 1 to 20 (default 20)
- `distortion_correction` (boolean): StarAlignment distortion correction; omitted, PixInsight's default
- `interpolation` (string): StarAlignment pixel interpolation; omitted, PixInsight's default
- `matrix_only` (boolean): Compute the registration only; keep no image files (default false)
- `output_dir` (string): Folder for registered files: relative to <workspace>/output, or absolute inside <workspace>/output or the state folder. Not used with matrix_only
- `output_postfix` (string): Suffix of registered file names (default "_r")
- `overwrite` (boolean): Overwrite existing registered files (default false)
- `reference_file` (string, required): Absolute path of the reference image file
- `target_files` (array, required): Absolute paths of the files to register

### `verify_astrometry` (~372 tokens)

Measure how well an open image's astrometric solution reproduces the sky, with the engine of PixInsight's AstrometricSolutionVerifier script (PixInsight 1.9.5 or later), run without its dialog: no deviation map, graphs, files or new windows, and the image is not modified. Every detected star is PSF-fitted, placed on the sky with the image's solution and compared with its Gaia DR3 star at the observation time. The result (JSON) gives the star counts (detected, PSF-fitted, matched, rejected by sigma clipping), the catalogue and its limit magnitude, the deviations (median, sigma, rms, 90th and 99th percentile, maximum) in pixels and arcseconds over the stars kept after sigma clipping and over all matched stars, the median bias, and the grid cell with the largest median deviation (cells with fewer than 3 matched stars are skipped) with its column, row and centre in image pixels. The view needs an astrometric solution.

Input parameters:

- `auto_magnitude` (boolean): Choose the catalogue limit magnitude automatically (script default true)
- `grid_cells` (integer): Number of grid cells along the largest image dimension, 1 to 255 (script default 8)
- `magnitude` (number): Catalogue limit magnitude used when auto_magnitude is false (script default 16)
- `matching_tolerance` (number): Maximum distance in pixels between a detected star and its catalogue position for a match (script default 3)
- `rejection_sigma` (number): Sigma-clipping factor on the deviations; matched stars beyond median + factor x sigma are left out of the retained statistics and the grid, 0 disables (script default 5)
- `view_id` (string, required): View ID to verify

### `run_plate_solve` (~443 tokens)

Plate solve an open image with ImageSolver against the local Gaia DR3/SP database (offline). Adds the astrometric solution needed by run_spfc, run_mgc and run_spcc. Needs an approximate position (ra_deg, dec_deg; within a fraction of the field is enough) and scale (pixel_scale in arcsec/px, or focal_length_mm + pixel_size_um) unless the image keywords already carry RA, DEC and FOCALLEN/XPIXSZ. If the seeded solve fails, it is retried with the scale seed multiplied by 0.5, 2, 1/3 and 3 in turn (scale_search false tries the seed only). The result gives the solved scale from the solution, the expected scale (the seed, or the one the keywords give) and their ratio, which is far from 1 for a master a stacker resampled or drizzled. Observation time is read from DATE-OBS/DATE, else today. The result also states whether distortion correction and recursive surface splines were on.

Input parameters:

- `dec_deg` (number): Approximate center Dec in degrees
- `focal_length_mm` (number): Focal length in mm (use with pixel_size_um instead of pixel_scale)
- `observation_jd` (number): Julian date of the observation (only if no DATE-OBS/DATE keyword)
- `pixel_scale` (number): Approximate pixel scale in arcsec/pixel
- `pixel_size_um` (number): Pixel size in microns
- `ra_deg` (number): Approximate center RA in degrees
- `recursive_splines` (boolean): ImageSolver's "Recursive surface splines" distortion option (ImageSolver 6.5.0, PixInsight 1.9.5): models distortion with all matched stars as local surface splines over a quadtree. Omitted, the opti…
- `scale_search` (boolean): Retry with wider scale seeds when the seeded solve fails (default true)
- `view_id` (string, required): View ID to plate solve

### `copy_astrometric_solution` (~86 tokens)

Copy the astrometric solution (WCS) and observation keywords from a source image file to a target view. Source and target must have the same dimensions; the target's pixels are unchanged.

Input parameters:

- `source_file` (string, required): Absolute path to the source image file that carries the WCS
- `target_id` (string, required): Target view ID to receive the WCS

### `catalog_stars` (~390 tokens)

List catalogue stars over a plate-solved view from PixInsight's local Gaia database: one Gaia search centred on the image, with a radius reaching its corners (plus margin_fraction), down to mag_limit. Per star: image x, y, RA, Dec, G, BP-RP where the catalogue has them, whether it falls inside the frame, and for in-frame stars the peak luminance in a 5x5 box (with saturated = peak >= saturation_level when that is given). data_release omitted: releases are asked get-info in the order DR3/SP, DR3, EDR3, DR2 and the earliest of them that reports valid is searched; a failed search is reported, not retried on another release. supplement adds stars the catalogue lacks (marked with their name); a Gaia star within merge_px of one is replaced by it. Sorted by G, brightest at the top. The full list is written to a JSON file under <workspace>/agentic/scratch/catalog; the reply carries it inline up to 200 stars.

Input parameters:

- `data_release` (string): Gaia data release to search; omitted, the earliest valid one in the order DR3/SP, DR3, EDR3, DR2
- `mag_limit` (number, required): Faintest G magnitude listed
- `margin_fraction` (number): Extra search radius as a fraction of the centre-to-corner radius (default 0.05)
- `merge_px` (number): Distance in pixels within which a Gaia star is replaced by a supplement star (default 3)
- `saturation_level` (number): Peak luminance at or above which an in-frame star is flagged saturated; omitted, no flag
- `supplement` (array): Stars to add: [{ra, dec, mag, name}] in degrees and catalogue-band magnitude
- `view_id` (string, required): Plate-solved view

### `combine_channels` (~100 tokens)

Combine 3 mono views into a single RGB color image using ChannelCombination. All 3 views must have identical dimensions. Returns the view ID of the combined image.

Input parameters:

- `b_view_id` (string, required): Blue channel view ID
- `g_view_id` (string, required): Green channel view ID
- `output_id` (string, required): Desired output view ID (the combined image is renamed to this)
- `r_view_id` (string, required): Red channel view ID

### `align_to_reference` (~64 tokens)

Align a target image to a reference image using StarAlignment. The target is replaced in place with the aligned version.

Input parameters:

- `reference_id` (string, required): Reference view ID (not modified)
- `target_id` (string, required): Target view ID (replaced with the aligned version)

### `run_per_channel_abe` (~188 tokens)

Run AutomaticBackgroundExtractor (ABE) separately on the R, G and B channels of a color view, then recombine them into the view with ChannelCombination. ChannelExtraction writes the channels to the temporary views __pca_R, __pca_G and __pca_B; ABE subtracts its model from each in place and discards the model; the temporary views and any other view the call opened are closed afterwards. An ABE parameter that is not given is left at PixInsight's default, as run_abe does.

Input parameters:

- `poly_degree` (integer): ABE polynomial degree for every channel (AutomaticBackgroundExtractor polyDegree); omitted = PixInsight default
- `tolerance` (number): ABE sample rejection tolerance for every channel (AutomaticBackgroundExtractor tolerance); omitted = PixInsight default
- `view_id` (string, required): RGB color view ID (modified in place)

### `lrgb_combine` (~288 tokens)

Replace the lightness of an RGB view with a grayscale L view using LRGBCombination, in place on the RGB view. Only the L channel is enabled, so the RGB view keeps its own color channels. lightness and saturation are LRGBCombination's transfer-function midtones balances mL and mc (0.5 leaves that component unchanged). When linear_fit_reject_high is given, the call also runs LinearFit on the L view (modified in place, ahead of the combination) against a temporary luminance image 0.2126 R + 0.7152 G + 0.0722 B of the RGB view; when it is omitted, no LinearFit runs. Chrominance noise reduction and highlight clipping are left at PixInsight's defaults.

Input parameters:

- `l_id` (string, required): Grayscale luminance view ID with the same dimensions as rgb_id
- `lightness` (number, required): Midtones balance of the lightness transfer function (LRGBCombination mL), 0 to 1
- `linear_fit_reject_high` (number): LinearFit rejectHigh for the fit of L to the RGB luminance; omitted = no LinearFit
- `rgb_id` (string, required): RGB color view ID (modified in place)
- `saturation` (number, required): Midtones balance of the saturation transfer function (LRGBCombination mc), 0 to 1

### `compare_images` (~176 tokens)

Compare two open views of the same width, height and channel count, pixel by pixel, over the whole image or a rectangle. Per channel: maximum, mean and 99th-percentile absolute difference, and the fraction of samples outside [0, 1] in each view. "identical" is true when every absolute difference is 0. The 99th percentile is taken over at most 2,000,000 evenly spaced samples (p99Samples says how many); maximum and mean use every sample. Neither view is changed.

Input parameters:

- `rect` (array): Optional region [x0, y0, x1, y1] in pixels, x1/y1 exclusive
- `reference_id` (string, required): Second view (B), compared against A
- `view_id` (string, required): First view (A)

### `multi_scale_enhance` (~630 tokens)

Masked three-scale LocalHistogramEqualization on a view, in one call, with an optional HDRMultiscaleTransform pass. The mask is the image lightness (CIE L* for colour, the image itself for mono) mapped as max((L - mask_clip_low) / (1 - mask_clip_low), 0), raised to the power 1/mask_gamma and blurred with a Gaussian of sigma mask_blur (0 = no blur). LHE then runs at the large, mid and fine radius in that order through the mask; the large and mid scales use lhe_slope_limit, the fine scale lhe_fine_slope_limit; other LHE parameters are PixInsight's defaults. Giving hdrmt_layers adds an HDRMultiscaleTransform pass through the same mask. The mask is closed afterwards. Reports a detail score before and after: the mean squared Sobel gradient of luminance (Rec.709 weights) over pixels brighter than median + 8 x 1.4826 x MAD, sampled every 8 pixels.

Input parameters:

- `hdrmt_inverted` (boolean): HDRMT inverted iterations (needs hdrmt_layers; omitted = PixInsight default)
- `hdrmt_iterations` (integer): HDRMT number of iterations (needs hdrmt_layers; omitted = PixInsight default)
- `hdrmt_layers` (integer): HDRMultiscaleTransform number of layers. Giving it runs the HDRMT pass; omitted, no HDRMT runs
- `hdrmt_median_transform` (boolean): HDRMT median transform instead of the wavelet transform (needs hdrmt_layers; omitted = PixInsight default)
- `hdrmt_to_lightness` (boolean): HDRMT toLightness: on a colour image, apply the transform to the lightness only (needs hdrmt_layers; omitted = PixInsight default)
- `lhe_fine_amount` (number, required): Fine-scale LHE amount, 0 to 1
- `lhe_fine_radius` (number, required): Fine-scale LHE kernel radius in pixels
- `lhe_fine_slope_limit` (number, required): LHE contrast slope limit of the fine scale
- `lhe_large_amount` (number, required): Large-scale LHE amount, 0 to 1
- `lhe_large_radius` (number, required): Large-scale LHE kernel radius in pixels
- `lhe_mid_amount` (number, required): Mid-scale LHE amount, 0 to 1
- `lhe_mid_radius` (number, required): Mid-scale LHE kernel radius in pixels
- `lhe_slope_limit` (number, required): LHE contrast slope limit of the large and mid scales
- `mask_blur` (number, required): Gaussian blur sigma of the mask in pixels (0 = no blur)
- `mask_clip_low` (number, required): Lightness mapped to 0 in the mask; values above it are rescaled to 0-1
- `mask_gamma` (number, required): Mask gamma: the rescaled mask is raised to the power 1/mask_gamma (1 = unchanged)
- `view_id` (string, required): View ID to enhance (modified in place)

### `shell_detail_enhance` (~485 tokens)

Protected high-pass detail enhancement at two scales, in place. For each scale, detail = image - Gaussian blur of sigma <scale>_sigma (locally zero-mean), and result = image + <scale>_amount x detail x protection, where protection = exp(-protect_softness x max(0, L - protect_knee) / max(1 - protect_knee, 0.01)) and L is Rec.709 luminance, so the boost attenuates above protect_knee. A scale with amount 0 is skipped. Output is truncated to [0, 1]. It does not hold the peak fixed: the added detail can raise the image maximum (the result reports the image maximum before and after, from full image statistics). With mask_id the enhancement runs through that mask; with auto_zone and no mask_id it builds the adaptive shell zone mask (as create_adaptive_zone_masks with its default core_bias), uses it and closes it, and fails without changing the view if that mask cannot be built; with neither it runs unmasked. Reports before/after texture metrics over pixels between median + 5 x 1.4826 x MAD and 0.98, sampled every 8 pixels: mean squared Sobel gradient, median local standard deviation of 16-pixel blocks that are at least 30% such pixels, and the share of them where protection is below 0.5.

Input parameters:

- `auto_zone` (boolean): With no mask_id: build the adaptive shell zone mask and enhance through it. If it cannot be built the call fails and the view is not modified
- `large_amount` (number, required): Large-scale detail multiplier (0 skips the scale)
- `large_sigma` (number, required): Gaussian sigma of the large-scale blur, in pixels
- `mask_id` (string): Mask view to enhance through (optional)
- `medium_amount` (number, required): Medium-scale detail multiplier (0 skips the scale)
- `medium_sigma` (number, required): Gaussian sigma of the medium-scale blur, in pixels
- `protect_knee` (number, required): Luminance above which the boost attenuates
- `protect_softness` (number, required): Attenuation rate above protect_knee (>= 0; higher = steeper)
- `view_id` (string, required): View to enhance (modified in place)

### `inspect_environment` (~379 tokens)

Report what this PixInsight installation has, by asking PixInsight. gaia: Gaia get-info for DR2, EDR3, DR3 and DR3/SP (valid, database files, magnitude range, mean spectra) and a 0.1-degree search on the lowest valid release. mars: one MultiscaleGradientCorrection run per MARS file (from PixInsight settings, or mars_files) on a temporary synthetic plate-solved image; per file: readable, missing or corrupt, and how many MARS reference images cover the probe position. xterminators: BlurXTerminator, NoiseXTerminator and StarXTerminator run once each on a temporary 64x64 image; reports version, ML model version and gpu/cpu from their console banner (null when not printed). processes: the PixInsight core version and build, whether MultiscaleAdaptiveStretch, MultiscaleGradientCorrection, BlurXTerminator, NoiseXTerminator and StarXTerminator are installed processes, and whether ImageSolver, AstrometricSolutionVerifier, DistortionEvaluator, FFTRegistration and MosaicByCoordinates are installed scripts, with the version each script declares; nothing is run. system: free and total memory, free space on the workspace volume. Temporary images are closed; open images are not touched. Without ra_deg/dec_deg the probe position is RA 0, Dec 0 and coverage is reported as null.

Input parameters:

- `dec_deg` (number): Probe position declination, degrees [-90, 90]. Given with ra_deg.
- `mars_files` (array): Absolute .xmars paths to test instead of the configured ones
- `ra_deg` (number): Probe position right ascension, degrees [0, 360). Given with dec_deg.
- `sections` (array): Sections to run (default: all)

### `run_pjsr` (~272 tokens)

Run a PJSR (JavaScript, V8 engine) snippet inside PixInsight and return its console output. Last resort for things the other tools do not cover. Call processEvents() before each long process (BXT, NXT, SXT) so Pause/Abort works. No ES6 module syntax; the snippet is eval-ed as a script, so #include does not work and a top-level return is a syntax error; `include` prepends files instead. Code that does not parse is refused with its line number before anything reaches PixInsight.

Input parameters:

- `async` (boolean): Run as a job: the call returns a job id at once and the code runs in PixInsight in the background. job_status reports on the job and returns its result; cancel_job stops it. While a job runs, other c…
- `code` (string, required): PJSR code. The value of the last expression is returned.
- `include` (array): Absolute paths of PJSR source files whose contents run before `code`, in this order, in the same scope, so functions they define can be called from `code`.

### `run_pixelmath` (~199 tokens)

Run an arbitrary PixelMath expression in place on a view. The result is truncated to [0,1]; the reply gives, per channel, the fraction of samples that were below 0 or above 1 before truncation, and their min and max. RULES: (1) NO pow() — use exp(exponent*ln(base)). (2) Channel access is $T[0] for R, $T[1] for G, $T[2] for B — NOT $T.R or $T.B. (3) For other images use viewId[0], viewId[1], viewId[2].

Input parameters:

- `expression` (string, required): PixelMath expression using $T for current pixel value
- `single_expression` (boolean): Apply the same expression to all channels (default true)
- `symbols` (string): Symbol declarations (comma-separated)
- `view_id` (string, required): View ID to process

### `pixelmath_new_image` (~300 tokens)

Run PixelMath to create a NEW image from expressions that reference other open views by id. Color "rgb" takes red/green/blue expressions; color "gray" takes a single expression. The new image is truncated to [0,1]; the reply gives, per channel, the fraction of samples that were below 0 or above 1 before truncation. When size_from has an astrometric solution it is copied onto the new image (same geometry), unless copy_astrometric_solution is false. View ids used inside expressions must be simple identifiers (rename_view renames a view). No pow() — use exp(exponent*ln(base)) or the ^ operator.

Input parameters:

- `blue` (string): Blue channel expression (color "rgb")
- `color` (string, required)
- `copy_astrometric_solution` (boolean): Copy size_from's astrometric solution onto the new image when it has one
- `expression` (string): Single expression for color "gray"
- `green` (string): Green channel expression (color "rgb")
- `output_id` (string, required): Id for the new image
- `red` (string): Red channel expression (color "rgb")
- `size_from` (string, required): A view whose width and height the new image copies
- `symbols` (string): PixelMath symbols; constants only, e.g. "k=0.3". Symbols cannot hold images: write image expressions inline.

### `run_process` (~210 tokens)

Instantiate any PixInsight process by its PJSR constructor name, assign JSON-valued parameters onto the instance, and execute it on a view (when view_id is given) or globally (when it is omitted). Generic fallback for processes with no dedicated tool. A params key that is not a parameter of the installed process is refused by name, since PixInsight would otherwise ignore it. A process that has the noGUIMessages property (Crop, DynamicCrop, Resample, IntegerResample, Rotation, FastRotation, ChannelMatch and others) runs with it set to true unless params sets it, so its confirmations and warnings go to the Process Console instead of a dialog.

Input parameters:

- `name` (string, required): PJSR process constructor name, e.g. "SCNR".
- `params` (object): Property name to JSON-valued setting, assigned on the process instance before it runs.
- `view_id` (string): View to run the process on. Omit to run the process globally instead.

### `run_pjsr_file` (~198 tokens)

Run a PJSR (JavaScript, V8 engine) source file from disk inside PixInsight and return its console output. Same execution model as run_pjsr, with the code read from a file instead of passed inline. No ES6 module syntax; the file content is eval-ed, so #include does not work. Code that does not parse is refused with its line number before anything reaches PixInsight.

Input parameters:

- `async` (boolean): Run as a job: the call returns a job id at once and the code runs in PixInsight in the background. job_status reports on the job and returns its result; cancel_job stops it. While a job runs, other c…
- `path` (string, required): Absolute path to the PJSR source file.

### `ensure_dir` (~110 tokens)

Create a folder, with any missing parents, inside the workspace's output folder or state folder. A relative path is resolved under <workspace>/output; an absolute one must lie inside <workspace>/output or the state folder (<workspace>/agentic by default), and a path anywhere else is refused. An existing folder is left as it is. Returns the absolute path.

Input parameters:

- `path` (string, required): Folder path: relative to <workspace>/output, or absolute inside <workspace>/output or the state folder

### `open_image` (~58 tokens)

Open an XISF/FITS image file in PixInsight. Returns the view ID assigned by PixInsight. Automatically closes any crop_mask windows that come with XISF files.

Input parameters:

- `file_path` (string, required): Absolute path to the image file

### `close_image` (~28 tokens)

Close an image window to free memory.

Input parameters:

- `view_id` (string, required): View ID to close

### `list_open_images` (~24 tokens)

List all currently open images in PixInsight with their dimensions and color status.

### `rename_view` (~57 tokens)

Rename an image view to a different view ID. Long XISF names can cause some PixInsight processes to fail.

Input parameters:

- `new_id` (string, required): New view ID (no spaces)
- `old_id` (string, required): Current view ID

### `clone_image` (~68 tokens)

Clone an image to a backup view, which can be restored from later with restore_from_clone. The clone keeps the image's FITS keywords, astrometric solution and view properties.

Input parameters:

- `clone_id` (string, required): Name for the clone
- `source_id` (string, required): Source view ID

### `restore_from_clone` (~53 tokens)

Restore an image from a backup clone, replacing all changes since the clone was made.

Input parameters:

- `clone_id` (string, required): Clone view ID to restore from
- `target_id` (string, required): Target view ID to overwrite

### `crop_image` (~171 tokens)

Crop pixels off the edges of an image, in place. Amounts are pixels to remove from each side. All four amounts 0 (or omitted) runs nothing and leaves the image, and its astrometric solution, unchanged. Crop runs with noGUIMessages, so PixInsight writes its warnings to the Process Console instead of opening a confirmation dialog. A crop deletes the image's astrometric solution (PixInsight behaviour); the result says when one was removed.

Input parameters:

- `bottom` (number): Pixels to remove from the bottom edge
- `left` (number): Pixels to remove from the left edge
- `right` (number): Pixels to remove from the right edge
- `top` (number): Pixels to remove from the top edge
- `view_id` (string, required): View ID to crop

### `get_image_dimensions` (~46 tokens)

Get dimensions, channel count, and color status for one or more views. Every channel must have identical dimensions before ChannelCombination.

Input parameters:

- `view_ids` (array, required): View IDs to check

### `get_image_stats` (~60 tokens)

Get image statistics: median, MAD, min, max, per-channel medians, and per channel the fraction of samples at exactly 0 and at exactly 1 (clampFractions).

Input parameters:

- `view_id` (string, required): PixInsight view ID

### `export_image` (~223 tokens)

Write an image to a file in the workspace's output or state folder. A relative file_path is resolved under <workspace>/output; an absolute one must lie inside <workspace>/output or the state folder (<workspace>/agentic by default), and a path anywhere else is refused. Format comes from the extension: .tif/.tiff, .png, .jpg/.jpeg, .xisf, .fits. TIFF and PNG default to 16-bit, JPEG to 8-bit; use 32 for float. The file keeps the image's FITS keywords, astrometric solution and view properties (formats that cannot store them drop them). The working image is not changed. Missing parent folders are created.

Input parameters:

- `bits` (number): Sample depth for tif/png/xisf/fits (default 16 for tif/png, 32 otherwise)
- `file_path` (string, required): Output file path: relative to <workspace>/output, or absolute inside <workspace>/output or the state folder
- `view_id` (string, required): View ID to export

### `list_processes` (~57 tokens)

List every PixInsight process available on this installation, by its PJSR constructor name (e.g. "SCNR", "PixelMath"). Read-only; classifies by prototype chain and never instantiates a process to build the list.

### `describe_process` (~71 tokens)

Describe one PixInsight process by its PJSR constructor name: whether it can run on a view and/or globally, its current parameter values and their types, and any named numeric constants it exposes for those parameters.

Input parameters:

- `name` (string, required): PJSR process constructor name, e.g. "SCNR".

### `create_luminance_mask` (~137 tokens)

Create a luminance mask from a color view: Y = 0.2126R + 0.7152G + 0.0722B, then an optional blur and shadow clip.

Input parameters:

- `blur` (number): Blur sigma applied to the mask (default 5)
- `clip_low` (number): Shadow clip threshold, below which the mask is 0 (default 0.10)
- `gamma` (number): Gamma curve applied to the mask (default 1.0)
- `mask_id` (string, required): Name for the mask
- `source_id` (string, required): Source color view ID

### `apply_mask` (~80 tokens)

Apply a mask to a target view. The mask protects areas where it is black (0) and allows processing where it is white (1). Use inverted=true to flip this.

Input parameters:

- `inverted` (boolean): Invert the mask (default false)
- `mask_id` (string, required): Mask view ID
- `target_id` (string, required): Target view ID

### `remove_mask` (~27 tokens)

Remove the current mask from a view.

Input parameters:

- `target_id` (string, required): Target view ID

### `close_mask` (~31 tokens)

Close and delete a mask window to free memory.

Input parameters:

- `mask_id` (string, required): Mask view ID to close

### `create_zone_masks` (~226 tokens)

Create core, shell and halo masks from three fixed luminance thresholds. Luminance is the Rec.709 luma of a color view, the samples of a gray one: core = above core_clip, shell = shell_clip to core_clip, halo = halo_clip to shell_clip, each ramped linearly from 0 to 1 across its band and Gaussian-blurred with sigma 8, 12 and 20. Creates views mask_core, mask_shell and mask_halo, replacing views of those names. Requires halo_clip < shell_clip < core_clip < 1.

Input parameters:

- `core_clip` (number, required): Luminance above which a pixel is in the core mask (0-1)
- `halo_clip` (number, required): Luminance above which a pixel, up to shell_clip, is in the halo mask (0-1)
- `shell_clip` (number, required): Luminance above which a pixel, up to core_clip, is in the shell mask (0-1)
- `view_id` (string, required): Source view the masks are computed from

### `create_adaptive_zone_masks` (~229 tokens)

Create three masks from percentiles of the image's own luminance. Subject pixels are those brighter than the background median + 5 MAD, sampled inside a circle of radius 0.35 * min(width, height) around their brightness-weighted centroid. Core = above the subject percentile 85 + 10 * core_bias; shell = a triangular ramp between the 25th percentile and the core level, peaking at their midpoint; outer = subject level up to the 25th percentile. Each is feathered over 20 px outside the circle and Gaussian-blurred with sigma 5, 10 and 20. Creates views azone_core, azone_shell and azone_outer, replacing views of those names; fewer than 50 sampled subject pixels is an error.

Input parameters:

- `core_bias` (number): Position of the core threshold on its 0-1 scale: 0 = percentile 85, 1 = percentile 95 (default 0.5, the middle of the scale)
- `view_id` (string, required): Source view the masks are computed from

### `measure_uniformity` (~57 tokens)

Measure background uniformity via 4-corner median stddev. Lower score means more uniform.

Input parameters:

- `sample_size` (integer): Corner sample size in pixels (default 200)
- `view_id` (string, required): PixInsight view ID

### `measure_stars` (~243 tokens)

Measure the stars of a view by pixel sampling. Candidates are local maxima of luminance found by a 16 px grid scan above median + 5 x MAD, refined within 5x5, de-duplicated within 20 px (at most 100 kept); the 30 brightest are measured. FWHM of a star = 2 x the mean radius, over the four axis directions (up to 10 px), where luminance drops below half its peak, located to a fraction of a pixel by linear interpolation between the samples either side; colour diversity of a star = max - min of its peak RGB divided by the largest channel. Returns JSON: median_fwhm_px, color_diversity (median), stars_found, stars_measured, median_peak, p25_peak, background_median, star_background_contrast (median_peak / background_median, 0 when background_median <= 0.001), and up to 10 samples of each. luminance is 0.2126R + 0.7152G + 0.0722B.

Input parameters:

- `view_id` (string, required): View to measure

### `measure_star_layer` (~189 tokens)

Measure a star layer (a mostly black view holding stars). Over every 4th pixel whose largest channel is above 0.005 (nonzero_pixel_count), reports the fraction whose largest channel is above each of the given levels, the interquartile range of their HSV saturation (color_diversity), and the median (max - min) / max of the 20 brightest by R+G+B (bright_star_chroma). Also the largest channel value (max) and the image median (the mean of the channel medians for colour). Returns JSON: max, median, fraction_above {level: fraction}, color_diversity, bright_star_chroma, nonzero_pixel_count.

Input parameters:

- `levels` (array, required): Pixel levels; for each, the fraction of star pixels whose largest channel is above it is reported
- `view_id` (string, required): Star layer view to measure

### `measure_ringing` (~209 tokens)

Measure concentric oscillation around the brightest region. The centre is the middle of the brightest 64 px block (mean luminance); the radial luminance profile is averaged over 36 angles for radii 1..150 px (held inside the image). Along the profile, derivatives within ±0.001 carry no sign; at each sign change the summed |derivative| of the run it ends is its amplitude, and it is counted when that amplitude is above min_amplitude. Returns JSON: oscillations, max_amplitude (of the counted ones), center [x, y], profile_sample (the profile at radii 1..30). luminance is 0.2126R + 0.7152G + 0.0722B.

Input parameters:

- `min_amplitude` (number, required): Amplitude (summed |derivative| of a run) above which a sign change is counted as an oscillation
- `view_id` (string, required): View to measure

### `measure_sharpness` (~194 tokens)

Measure sharpness as the mean Sobel gradient energy (gx² + gy²) of luminance over every 4th pixel of a region. The region is roi_x/roi_y/roi_w/roi_h when all four are given (it must lie inside the image), else the central half of the image in each dimension. Returns JSON: sharpness, samples, roi {x, y, w, h}. luminance is 0.2126R + 0.7152G + 0.0722B.

Input parameters:

- `roi_h` (number): Region height in pixels
- `roi_w` (number): Region width in pixels
- `roi_x` (number): Region left edge in pixels (all four ROI values together, or none: the central half)
- `roi_y` (number): Region top edge in pixels
- `view_id` (string, required): View to measure

### `measure_core_clipping` (~166 tokens)

Measure how much of the brightest region is above a level. Around the brightest 64 px block (mean luminance), counts pixels with any channel above level in a 128 px box (every 2nd pixel) and a 32 px box (every pixel), both centred on that block and held inside the image. Returns JSON: fraction_above_wide, fraction_above_inner, peak (largest luminance in the wide box), core_center [x, y], wide_box, inner_box. luminance is 0.2126R + 0.7152G + 0.0722B.

Input parameters:

- `level` (number, required): Pixel level; a pixel with any channel above it is counted
- `view_id` (string, required): View to measure

### `measure_clipped_blocks` (~193 tokens)

Count image blocks with pixels above a level. Tiles the image in block_size px blocks and samples every 3rd pixel; a sample counts when its luminance or any channel is above level, and a block counts when more than block_fraction of its samples do. Returns JSON: blocks_over, total_blocks, locations (up to 10 counted blocks in descending fraction order: x, y, fraction). luminance is 0.2126R + 0.7152G + 0.0722B.

Input parameters:

- `block_fraction` (number, required): Fraction of a block's samples (0-1) that must be above level for the block to count
- `block_size` (integer): Block edge in pixels (default 50)
- `level` (number, required): Pixel level; a sample whose luminance or any channel is above it counts
- `view_id` (string, required): View to measure

### `measure_highlight_texture` (~322 tokens)

Measure the texture of the bright subject zone. Subject pixels have luminance above median + 5 x (median |luminance - median| on a 32 px grid). The ROI is a circle around the luminance-weighted centroid of compact subject pixels (8 px grid, at least 2 of 4 neighbours 3 px away also subject), radius = their 90th-percentile distance held to [50 px, 0.45 x min(width, height)]. The shell zone is the P20..P92 band of the subject pixels in the ROI (every 4th pixel). local_stddev = median luminance stddev of 16 px blocks in the ROI whose samples are at least 40% shell; tonal_span = P90 - P10 of the shell pixels; gradient_energy = mean Sobel energy on shell pixels. With reference_id, the reference is measured over the same ROI and retention is current / reference for each value (null where the reference value is at most 0.0001, or 0.001 for tonal_span). Returns JSON: current, reference, retention, shell_zone, roi, shell_pixel_count, block_count. Fewer than 100 subject pixels in the ROI of either view is an error. luminance is 0.2126R + 0.7152G + 0.0722B.

Input parameters:

- `reference_id` (string): Optional second view measured over the same ROI, for the retention ratios
- `view_id` (string, required): View to measure

### `measure_saturation` (~127 tokens)

Measure HSV saturation, (max - min) / max, of subject pixels of a colour view: every 8th pixel whose luminance is above the luminance of the channel medians + 5 x (median |luminance - that| on a 32 px grid). Returns JSON: median, p90, p99, max, subject_pixel_count. A mono view is an error. luminance is 0.2126R + 0.7152G + 0.0722B.

Input parameters:

- `view_id` (string, required): Colour view to measure

### `measure_tonal_presence` (~276 tokens)

Measure subject and background tones. Every 8th pixel is subject when its luminance is above the background (luminance of the channel medians) + 5 x (median |luminance - background| on a 32 px grid) and at least 2 of its 4 neighbours 3 px away are too; every other sample is background. separation = subject median / background median; core_brightness = mean of the brightest 5% of subject samples; core_to_disk = core_brightness / subject median; faint_structure_visibility = (subject P10 - background P90) / background P90; subject_fraction = subject samples / all samples; roi_mode is compound_roi when a second luminance-weighted cluster, outside 0.15 x width of the centroid and holding over 15% of the weight, lies more than 0.25 x width away, else single. Denominators are held to at least 0.001. Returns JSON: separation, subject_median, background_median, core_brightness, faint_structure_visibility, core_to_disk, subject_fraction, roi_mode, subject_pixel_count. luminance is 0.2126R + 0.7152G + 0.0722B.

Input parameters:

- `view_id` (string, required): View to measure

### `measure_bright_chroma` (~115 tokens)

Measure chroma, (max - min) / max, of the bright pixels of a colour view: every 8th pixel whose mean of R, G and B is above brightness_threshold. Returns JSON: median_chroma, mean_chroma, p25_chroma, p75_chroma, bright_pixel_count. A mono view is an error.

Input parameters:

- `brightness_threshold` (number, required): Mean of R, G and B above which a pixel is measured
- `view_id` (string, required): Colour view to measure

### `measure_subject_detail` (~200 tokens)

Measure subject brightness, detail and contrast. The image is split into 32 px blocks; a block is subject when its luminance median is above median + 8 x 1.4826 x MAD. subject_brightness = median of subject block medians; background_median = median of the other block medians; contrast_ratio = subject_brightness / background_median (0 when that is at most 0.001); detail_score = mean Sobel energy of luminance over every 4th pixel of up to 50 subject blocks; subject_count = subject blocks; subject_threshold = median + 3 x 1.4826 x MAD. Returns JSON: subject_brightness, detail_score, contrast_ratio, subject_count, background_median, subject_threshold. luminance is 0.2126R + 0.7152G + 0.0722B.

Input parameters:

- `view_id` (string, required): View to measure

### `ha_inject_red` (~241 tokens)

Add Ha to the red channel of an RGB view in place, where Ha exceeds R by a given fraction. Where Ha > R * (1 + brightness_limit), R becomes R + strength * (Ha - R); elsewhere R, and G and B everywhere, are unchanged. With max_output and rolloff, R above max_output becomes max_output + (R - max_output) * rolloff. Runs as 64-bit PixelMath truncated to [0,1]; reports the new R maximum and the image median and max.

Input parameters:

- `brightness_limit` (number, required): Ha is added only where Ha > R * (1 + brightness_limit)
- `ha_id` (string, required): Ha view (mono, same dimensions)
- `max_output` (number): Optional: R level above which the soft clamp compresses; given together with rolloff. Omitted = no clamp
- `rolloff` (number): Fraction of the excess above max_output that is kept; given together with max_output
- `strength` (number, required): Fraction of the Ha excess over R added to R
- `target_id` (string, required): Target RGB view, modified in place

### `ha_inject_luminance` (~125 tokens)

Raise the luminance of an RGB view in place where Ha exceeds it, keeping colour ratios. With Y the Rec.709 luminance, each channel is multiplied by (Y + strength * max(Ha - Y, 0)) / Y. Runs as 64-bit PixelMath truncated to [0,1].

Input parameters:

- `ha_id` (string, required): Ha view (mono, same dimensions)
- `strength` (number, required): Fraction of the Ha excess over the luminance that is added
- `target_id` (string, required): Target RGB view, modified in place

### `extract_pseudo_oiii` (~109 tokens)

Create a mono view from the B channel of an RGB view minus its scaled R channel. OIII = max(0, B - continuum_factor * R); any view of that name is replaced. Reports the new view's median and max.

Input parameters:

- `continuum_factor` (number, required): Multiplier on R subtracted from B
- `output_id` (string): Name of the view to create; omitted = OIII_pseudo
- `rgb_id` (string, required): Source RGB view

### `continuum_subtract_ha` (~114 tokens)

Subtract the scaled R channel of an RGB view from an Ha view, in place. Ha = max(0, Ha - continuum_factor * R). Runs as 64-bit PixelMath truncated to [0,1]; reports the new median and max.

Input parameters:

- `continuum_factor` (number, required): Multiplier on R subtracted from Ha
- `ha_id` (string, required): Ha view (mono), modified in place
- `rgb_id` (string, required): RGB view whose R channel is subtracted (same dimensions)

### `dynamic_narrowband_blend` (~382 tokens)

Add Ha and OIII (mono views) to an RGB view in place, through a temporary luminance mask. R += ha_strength * Ha; B += oiii_strength * OIII; G += f * ha_strength * g_ha_fraction * Ha + (1 - f) * g_strength * OIII, with f = (OIII*Ha)^(1-OIII*Ha). Each channel above max_output becomes max_output + (x - max_output) * rolloff. The mask is the Rec.709 luminance of the target, Gaussian-blurred with sigma mask_blur, then 0 below mask_clip and (x - mask_clip) / (1 - mask_clip) above it; it is removed afterwards. Runs as 64-bit PixelMath truncated to [0,1]; reports the median and the R and B maxima.

Input parameters:

- `g_ha_fraction` (number, required): Fraction of ha_strength applied to Ha in the G term
- `g_strength` (number, required): Multiplier on OIII in the G term
- `ha_id` (string, required): Ha view (mono, same dimensions)
- `ha_strength` (number, required): Multiplier on Ha added to R
- `mask_blur` (number, required): Gaussian sigma (pixels) of the luminance mask blur
- `mask_clip` (number, required): Mask level below which the blend does not apply; 0 = no clip
- `max_output` (number, required): Per-channel level above which the soft clamp compresses
- `oiii_id` (string, required): OIII view (mono, same dimensions)
- `oiii_strength` (number, required): Multiplier on OIII added to B
- `rolloff` (number, required): Fraction of the excess above max_output that is kept
- `target_id` (string, required): Target RGB view, modified in place

### `create_synthetic_luminance` (~181 tokens)

Create a mono view from a weighted sum of Ha and OIII. It is ha_weight * Ha + oiii_weight * OIII, replacing any view of that name; with max_value the result is min(…, max_value); it is then truncated to [0,1]. Reports the new view's median and max.

Input parameters:

- `ha_id` (string, required): Ha view (mono)
- `ha_weight` (number, required): Multiplier on Ha
- `max_value` (number): Optional: upper cap on the result. Omitted = truncation to [0,1] only
- `oiii_id` (string, required): OIII view (mono, same dimensions)
- `oiii_weight` (number, required): Multiplier on OIII
- `output_id` (string): Name of the view to create; omitted = SYNTH_L

### `save_preview` (~312 tokens)

Save a JPEG preview of a view and return the file path. Optionally a crop region, a downsample factor, and an STF (display stretch) baked into the pixels: the STF of a view (stf_from) or a linked one given as stf_m and stf_c0. Without an STF the JPEG holds the view's pixel values as they are. The view itself is not changed.

Input parameters:

- `crop` (array): Region [x0, y0, x1, y1] of the view in pixels (x1, y1 exclusive); the whole view when omitted
- `downsample` (number): Divide width and height by this factor (>= 1). Omitted: the preview is scaled down to at most 2048 px on its longer side
- `label` (string, required): Short label for this preview (e.g. "after_stretch", "final")
- `stf_c0` (number): Shadows clipping point of the linked STF given with stf_m (0 <= c0 < 1)
- `stf_from` (string): Bake this view's STF (its display stretch) into the JPEG; the view may be view_id itself. Several previews given the same stf_from are stretched identically
- `stf_m` (number): Bake a linked STF with this midtones balance (0 < m < 1) into the JPEG; needs stf_c0
- `view_id` (string, required): PixInsight view ID

### `save_and_show_preview` (~249 tokens)

Alias for save_preview. Save a JPEG preview of a view and return the file path.

Input parameters:

- `crop` (array): Region [x0, y0, x1, y1] of the view in pixels (x1, y1 exclusive); the whole view when omitted
- `downsample` (number): Divide width and height by this factor (>= 1). Omitted: the preview is scaled down to at most 2048 px on its longer side
- `label` (string, required): Short label for this preview (e.g. "after_stretch", "final")
- `stf_c0` (number): Shadows clipping point of the linked STF given with stf_m (0 <= c0 < 1)
- `stf_from` (string): Bake this view's STF (its display stretch) into the JPEG; the view may be view_id itself. Several previews given the same stf_from are stretched identically
- `stf_m` (number): Bake a linked STF with this midtones balance (0 < m < 1) into the JPEG; needs stf_c0
- `view_id` (string, required): PixInsight view ID

### `run_scnr` (~68 tokens)

Run SCNR (Subtractive Chromatic Noise Reduction) to remove a green colour cast from a view.

Input parameters:

- `amount` (number): Green removal amount, 0 to 1.
- `protection` (string): Protection method.
- `view_id` (string, required): PixInsight view identifier.

### `run_gradient_correction` (~34 tokens)

Run GradientCorrection on a view to remove a background gradient.

Input parameters:

- `view_id` (string, required): PixInsight view identifier.

### `run_background_neutralization` (~36 tokens)

Run BackgroundNeutralization to equalize the background level across channels.

Input parameters:

- `view_id` (string, required): PixInsight view identifier.

### `run_nxt` (~95 tokens)

Run NoiseXTerminator to reduce noise on a view.

Input parameters:

- `denoise` (number, required): Denoise strength, 0 to 1.
- `detail` (number): Detail preservation, 0 to 1.
- `ml_version` (number): Neural network model version (the process's ml_version parameter). Omitted, the process keeps its own setting.
- `view_id` (string, required): PixInsight view identifier.

### `linear_fit` (~73 tokens)

Run LinearFit to scale a linear image to match a reference view. The reference is not modified.

Input parameters:

- `reference_id` (string, required): Reference view ID.
- `reject_high` (number): High rejection threshold.
- `reject_low` (number): Low rejection threshold.
- `view_id` (string, required): PixInsight view identifier.

### `run_lhe` (~130 tokens)

Run LocalHistogramEqualization (contrast-limited local histogram equalization) on a view. Omitted parameters keep PixInsight's defaults.

Input parameters:

- `amount` (number): Blend of the equalized result with the original, 0 to 1.
- `circular_kernel` (boolean): Circular kernel (true) or square kernel (false).
- `histogram_resolution` (string): Histogram resolution: 8, 10 or 12 bits.
- `radius` (number): Kernel radius in pixels.
- `slope_limit` (number): Contrast slope limit.
- `view_id` (string, required): PixInsight view identifier.

### `run_bxt` (~190 tokens)

Run BlurXTerminator on a view. correct_only applies PSF correction without sharpening; otherwise sharpen_nonstellar and sharpen_stellar (the process's sharpen_stars parameter) control sharpening strength. ml_version is the process's neural network model version; omitted, the process keeps its own setting.

Input parameters:

- `adjust_star_halos` (number): Star halo adjustment, -1 to 1 (default 0.0)
- `correct_only` (boolean): Correct-only mode: PSF correction with no sharpening
- `ml_version` (number): Neural network model version (the process's ml_version parameter)
- `sharpen_nonstellar` (number): Non-stellar sharpening, 0 to 1 (default 0.50)
- `sharpen_stellar` (number): Stellar sharpening, 0 to 1 (default 0.50)
- `view_id` (string, required): View ID to process

### `run_sxt` (~182 tokens)

Run StarXTerminator to separate stars from a view, replacing it in place with the starless result and producing a separate stars view. is_linear selects the unscreen mode: off for linear (pre-stretch) data, on for non-linear (stretched) data.

Input parameters:

- `is_linear` (boolean, required): Whether the image is linear (pre-stretch)
- `ml_version` (number): Neural network model version (the process's ml_version parameter). Omitted, the process keeps its own setting.
- `overlap` (number): Tile overlap (default 0.5). The former default 0.10 left a faint rectangular tile grid (cells of about 470 px) in linear starless images; 0.5 did not.
- `view_id` (string, required): View ID to extract stars from (modified in place to become starless)

### `run_abe` (~77 tokens)

Run AutomaticBackgroundExtractor (ABE) on a view, replacing it in place with the corrected result.

Input parameters:

- `poly_degree` (integer): Polynomial degree, 1 to 6 (default 4)
- `tolerance` (number): Sample rejection tolerance (default 1.0)
- `view_id` (string, required): View ID to process

### `run_hdrmt` (~134 tokens)

Run HDRMultiscaleTransform on a view. Inverted mode enhances detail; normal mode compresses dynamic range.

Input parameters:

- `inverted` (boolean): Inverted mode (enhances detail instead of compressing)
- `iterations` (integer): Number of iterations (default 1)
- `layers` (integer, required): Number of decomposition layers, 4 to 8 (default 6)
- `preserve_hue` (boolean): Preserve hue for color images (default true)
- `to_lightness` (boolean): Apply to lightness only for color images (default true)
- `view_id` (string, required): View ID to process

### `run_curves` (~116 tokens)

Apply a CurvesTransformation to a view. Provide control points as [[x,y], ...] for the desired channel: "RGB" (all), "L" (lightness), "S" (saturation), "R", "G", "B".

Input parameters:

- `channel` (string, required): Channel to apply the curve to
- `points` (array, required): Control points [[x,y], ...] from (0,0) to (1,1). Include endpoints.
- `view_id` (string, required): View ID to process

### `find_filters` (~148 tokens)

Search PixInsight's built-in filter and camera QE database by name (case-insensitive substring). A grouped name also matches each name it stands for ("Sony IMX411/455/461/533/571" matches "IMX533"); results are ordered exact name, then substring, then grouped-name matches. Use it to pick exact names for run_spfc or run_spcc. Sensor QE curves have channel Q.

Input parameters:

- `channel` (string): Optional: R, G, B, L, PAN (multiband OSC) or Q (sensor QE)
- `query` (string): e.g. "Astronomik", "Ha", "IMX533", "Chroma"

### `run_spfc` (~318 tokens)

Run SpectrophotometricFluxCalibration: writes the flux metadata that run_mgc requires. The image must be plate-solved and linear. Needs the camera QE curve (default "Ideal QE curve"; pass qe_name for the real sensor, see find_filters) and the filter curve. MONO image: pass filter (L, R, G, B, Ha, OIII, SII) and optionally filter_name (a measured curve from the database; otherwise a flat passband from wavelength_nm/bandwidth_nm is used). COLOR image: omit filter and pass red_filter_name, green_filter_name, blue_filter_name (otherwise flat R/G/B passbands).

Input parameters:

- `bandwidth_nm` (number): Mono: filter bandwidth in nm, if filter_name is not given
- `blue_filter_name` (string): Color: measured B filter curve name from find_filters
- `filter` (string): Mono only. One of L, R, G, B, Ha, OIII, SII
- `filter_name` (string): Mono: measured filter curve name from find_filters
- `green_filter_name` (string): Color: measured G filter curve name from find_filters
- `qe_name` (string): Camera QE curve name (default "Ideal QE curve")
- `red_filter_name` (string): Color: measured R filter curve name from find_filters
- `view_id` (string, required): View ID to calibrate
- `wavelength_nm` (number): Mono: filter center wavelength in nm, if filter_name is not given

### `run_spcc` (~521 tokens)

Run SpectrophotometricColorCalibration (SPCC). Requires the image to have an astrometric solution (run_plate_solve adds one) and to be linear (not stretched). Narrowband mode (narrowband_mode true) calibrates each channel as a narrow band: give the real filter centre and width per channel (red_/green_/blue_wavelength_nm and _bandwidth_nm; PixInsight's defaults are 656.3 / 500.7 / 500.7 nm and 3 nm for every band, wrong for a 5 nm H-alpha filter). The white reference matters for star colour: use a solar-type reference such as "G2V Star"; the default "Average Spiral Galaxy" makes a galaxy neutral and tints stars.

Input parameters:

- `blue_bandwidth_nm` (number): Narrowband mode: bandwidth of the blue channel's filter in nm (PixInsight default 3)
- `blue_filter_name` (string): Measured B filter curve name, as listed by find_filters
- `blue_wavelength_nm` (number): Narrowband mode: centre wavelength of the blue channel's filter in nm (default 500.7)
- `green_bandwidth_nm` (number): Narrowband mode: bandwidth of the green channel's filter in nm (PixInsight default 3)
- `green_filter_name` (string): Measured G filter curve name, as listed by find_filters
- `green_wavelength_nm` (number): Narrowband mode: centre wavelength of the green channel's filter in nm (default 500.7)
- `narrowband_mode` (boolean): Enable narrowband mode (default false)
- `qe_name` (string): Camera QE curve name (find_filters channel Q)
- `red_bandwidth_nm` (number): Narrowband mode: bandwidth of the red channel's filter in nm (PixInsight default 3)
- `red_filter_name` (string): Measured R filter curve name, as listed by find_filters. Set all three filters and qe_name together for a full calibration.
- `red_wavelength_nm` (number): Narrowband mode: centre wavelength of the red channel's filter in nm (default 656.3)
- `view_id` (string, required): View ID to calibrate (must be linear, must have a WCS/astrometric solution)
- `white_reference` (string): White reference name from PixInsight's database, e.g. "Average Spiral Galaxy", "G2V Star"
- `white_reference_name` (string): Same as white_reference

### `run_mgc` (~247 tokens)

Run MultiscaleGradientCorrection using the MARS reference database. The image must be plate-solved and linear; a mono image also needs the flux metadata run_spfc writes. For a mono image pass filter (L, R, G, B, Ha, OIII, SII); a mono image without filter is refused, since MGC would then fit its model against a MARS band that is not the image's. For a color image leave it out (R, G, B bands are used). MARS files default to the ones configured in PixInsight.

Input parameters:

- `filter` (string): Mono only. One of L, R, G, B, Ha, OIII, SII
- `gradient_scale` (number): Gradient scale in pixels (default 1024)
- `mars_files` (array): Absolute .xmars paths (default: from PixInsight settings)
- `model_smoothness` (number): Model smoothness (default 1)
- `show_model` (boolean): Also create the gradient model window
- `structure_separation` (number): Structure separation (default 3)
- `view_id` (string, required): View ID to process

### `reproject_to_reference` (~279 tokens)

Resample a plate-solved image onto the pixel grid of another plate-solved image, using the two astrometric solutions (PixInsight's astrometric reprojection): the result has the reference's size and solution and comes from a single interpolation of the source. Use it to bring a master from another telescope or session onto a reference grid; both views need a solution (run_plate_solve). The source is not changed; the result is a new 32-bit float view (output_id, default <view_id>_reprojected). It reports the size, the time and whether the result is empty (the two fields do not overlap). Registration accuracy is set by the two solutions, so check the star-centroid residual of the result against the reference.

Input parameters:

- `clamp` (number): Clamping threshold of the Lanczos and bicubic interpolations, 0 to 1 (default 0.3)
- `interpolation` (string): Pixel interpolation (default Lanczos3)
- `output_id` (string): View ID of the result (default <view_id>_reprojected)
- `reference_id` (string, required): View whose size and astrometric solution the result takes (needs an astrometric solution)
- `view_id` (string, required): Source view to reproject (needs an astrometric solution)

### `resample_image` (~330 tokens)

Change an image's pixel dimensions. mode "integer": IntegerResample by a whole factor (factor 2 bins 2x2 into one pixel with the given downsampling combination; enlarge: true multiplies the size instead). mode "scale": Resample by a relative factor (0.5 halves each side). mode "to_reference": Resample to exactly the width and height of reference_id. Runs in place, or on a copy named output_id that carries the keywords, astrometric solution and view properties. FITS keywords are kept. PixInsight removes the astrometric solution in these processes; the result states whether a solution was present before and after. Runs without the geometry confirmation dialog (noGUIMessages).

Input parameters:

- `downsampling` (string): integer mode: how binned pixels combine (default Average)
- `enlarge` (boolean): integer mode: multiply the size by factor instead of dividing it (default false)
- `factor` (number): integer: whole bin/zoom factor >= 2. scale: relative size factor > 0
- `interpolation` (string): scale / to_reference: Resample interpolation; omitted, PixInsight's default
- `mode` (string, required): integer (IntegerResample), scale (Resample by a factor) or to_reference (Resample to reference_id's size)
- `output_id` (string): Resample a copy with this view id instead of the view itself
- `reference_id` (string): to_reference: the view whose width and height the result takes
- `view_id` (string, required): View to resample

### `pixinsight_info` (~38 tokens)

Report the resolved PixInsight installation paths for this platform and the connector version. Read-only. For live process status, use the doctor command.

### `star_protected_blend` (~400 tokens)

Blend a stars-only image into a starless one in place, as a screen blend that turns colour-preserving in bright star cores. The mode follows, per pixel, the star layer's own luminance SL (the mean of its three channels). Below core_threshold_low: per-channel screen blend 1 - (1 - target) * (1 - stars * k). Above core_threshold_high: luminance-only screen blend, the target's colour scaled by the new over the old luminance and capped at max_value. Between them the two blend linearly. k = strength * prot, where prot falls linearly from 1 at core_threshold_low to min_strength_fraction at core_threshold_high. With pre_star_id, the bright-area colour ratios of that view are then restored over the same luminance ramp (see restore_star_color). Runs as 64-bit PixelMath truncated to [0,1]; reports the target's median and max before and after.

Input parameters:

- `core_threshold_high` (number, required): Star luminance SL at and above which the pure colour-preserving blend applies and protection is min_strength_fraction; greater than core_threshold_low
- `core_threshold_low` (number, required): Star luminance SL at and below which the pure screen blend applies and protection is 1
- `max_value` (number, required): Upper cap on each channel of the colour-preserving blend, and of the colour restoration when pre_star_id is given
- `min_strength_fraction` (number, required): Protection factor reached at core_threshold_high (strength is multiplied by it)
- `pre_star_id` (string): Optional: RGB view whose colour ratios are restored in bright areas after the blend; empty or absent = no restoration
- `stars_id` (string, required): Stars-only RGB view
- `strength` (number, required): Multiplier k on the star layer in the screen blend, before protection
- `target_id` (string, required): Starless RGB view, modified in place

### `restore_star_color` (~218 tokens)

Restore the colour ratios of a reference view in the bright areas of a target, in place, keeping the target's luminance. Per channel: restored = min(reference[c] * Lt / max(Lr, 0.001), max_value), where Lt and Lr are the target's and the reference's channel means; it is weighted in linearly from 0 at reference luminance restore_start to 1 at restore_end. Runs as 64-bit PixelMath truncated to [0,1]; reports the target's median and max before and after.

Input parameters:

- `max_value` (number, required): Upper cap on each restored channel
- `pre_star_id` (string, required): Reference RGB view whose colour ratios are restored (open, same dimensions)
- `restore_end` (number, required): Reference luminance at and above which the restored colour fully replaces the target; greater than restore_start
- `restore_start` (number, required): Reference luminance at and below which the target is unchanged
- `target_id` (string, required): RGB view to modify in place

### `robust_median_stretch` (~523 tokens)

Stretch a linear view in place so its median lands on target_median. Per pass: from the median M and the unnormalized median absolute deviation D of the image (range clipping off, alpha excluded), sigma = 1.4826·D and the black point c0 = max(0, M − black_point_sigma·sigma); samples are rescaled to u = clamp((x − c0)/(1 − c0), 0, 1), and the midtones transfer function MTF(m, u) = (m − 1)·u / ((2m − 1)·u − m) is applied with the balance m solved so that MTF(m, u(M)) = target_median exactly. linked true takes one set of statistics over all channels jointly; false takes them per channel. Each further pass repeats this on the previous output, re-measuring the statistics; passes before the last run on a scratch copy, so the view is written once and is left unmodified when any pass cannot be solved (a median on the black point, e.g. D = 0). With highlight_knee h and highlight_midtones mh, values y above h become h + (1 − h)·MTF(mh, (y − h)/(1 − h)) after the last pass. The result is JSON: per pass and per statistics group M, D, sigma, c0, the rescaled median xbar and m.

Input parameters:

- `black_point_sigma` (number, required): Distance of the black point below the median, in units of 1.4826·MAD (>= 0)
- `highlight_knee` (number): Output level above which values are compressed, strictly between 0 and 1. Given together with highlight_midtones; omitted = no highlight compression.
- `highlight_midtones` (number): MTF balance applied to the segment above highlight_knee, strictly between 0.5 and 1. Given together with highlight_knee.
- `linked` (boolean): Colour images only, required for them: true = joint statistics over all channels and one transform for all; false = statistics and transform per channel. Ignored for a grayscale image.
- `passes` (integer): Number of times the whole procedure runs, each on the previous output (>= 1; omitted = 1)
- `target_median` (number, required): Median of the output, strictly between 0 and 1
- `view_id` (string, required): View to stretch (modified in place)

### `stretch_stars` (~228 tokens)

Stretch a linear star image in place with a pedestal subtraction and a repeated midtones transfer function. When the image median is above 1e-5 it is subtracted as a pedestal and the rest rescaled, max(0, (x − median)/(1 − median)); then the midtones transfer function MTF(m, x) = (1 − m)·x / ((1 − 2m)·x + m) is applied `iterations` times with m = midtone. Results are truncated to [0,1]. The result reports the pedestal, the final median and maximum, and high_fraction: among pixels sampled every 16 pixels whose value (the channel maximum) exceeds 0.005 before the stretch, the fraction above 0.5.

Input parameters:

- `iterations` (integer, required): Number of times the MTF is applied (>= 1)
- `midtone` (number, required): MTF midtones balance m, strictly between 0 and 1 (m < 0.5 brightens)
- `view_id` (string, required): Star image view ID

### `auto_stretch` (~396 tokens)

Stretch a view in place with PixInsight's auto-stretch (the ScreenTransferFunction Auto Stretch computation), applied as a HistogramTransformation. Per channel, sigma = 1.4826 × MAD (the median absolute deviation from the median). A channel whose median is below 0.5 gets shadows clipping c0 = median + shadows_clipping × sigma, clamped to [0,1] (0 when sigma is 0), and midtones balance m = MTF(target_bg, median − c0), where MTF(m, x) = (m − 1)·x / ((2m − 1)·x − m); a channel whose median is above 0.5 is treated as inverted: highlights clipping c1 = median − shadows_clipping × sigma (1 when sigma is 0) and m = MTF(c1 − median, target_bg). linked: one transform for R, G and B, with c0 (or c1) the mean over channels of the per-channel clipping points (a channel with sigma 0 adds 0, or 1 for c1) and the mean median in place of the median; the image is treated as inverted only when every channel median is above 0.5. The defaults of shadows_clipping, target_bg and linked are PixInsight's auto-stretch defaults. Fails, changing nothing, when the clipping point leaves no range for a midtones balance.

Input parameters:

- `linked` (boolean): Colour images: true computes one transform for R, G and B; false computes one per channel. Ignored for mono images
- `shadows_clipping` (number): Clipping point relative to the median, in units of sigma = 1.4826 × MAD
- `target_bg` (number): Target background level, strictly between 0 and 1
- `view_id` (string, required): View ID to stretch

### `set_stf` (~281 tokens)

Set the ScreenTransferFunction (display stretch) of a view without changing its pixels, and return it as rows [m, c0, c1, r0, r1] for R, G, B (K for mono) and luminance. Either copy the STF of from_view_id, or compute PixInsight's auto-stretch exactly as auto_stretch does (per channel sigma = 1.4826 × MAD; c0 = median + shadows_clipping × sigma; m = MTF(target_bg, median − c0); linked: one set of values for R, G and B from the mean clipping point and mean median). An STF is stored with the view and saved in XISF files.

Input parameters:

- `from_view_id` (string): Copy this view's STF instead of computing one; target_bg, shadows_clipping and linked are then not allowed
- `linked` (boolean): Colour images: true computes one set of values for R, G and B; false one per channel. Ignored for mono images
- `shadows_clipping` (number): Clipping point relative to the median, in units of sigma = 1.4826 × MAD
- `target_bg` (number): Target background level, strictly between 0 and 1
- `view_id` (string, required): View whose STF is set

### `continuous_clamp` (~309 tokens)

Compress bright values in place above a knee that varies per pixel. A luminance image (Rec.709 weights for colour) is blurred with a Gaussian of sigma blur_sigma and divided by its maximum, giving L in [0,1]; the knee is min_clamp + (max_clamp − min_clamp)·(1 − L), so it equals min_clamp where L = 1 and max_clamp where L = 0. mode soft: a value above the knee becomes knee + headroom·(1 − exp(−rate·(value − knee)/headroom)); mode hard: min(value, knee). The same expression is applied to every channel and the result is truncated to [0,1].

Input parameters:

- `blur_sigma` (number): Gaussian blur sigma of the luminance mask, in pixels; omitted = max(60, round(image width / 100))
- `headroom` (number): Soft mode, required there: the most the output can exceed the knee
- `max_clamp` (number, required): Knee where the blurred luminance is 0
- `min_clamp` (number, required): Knee where the blurred luminance is at its maximum
- `mode` (string, required): soft: exponential compression above the knee; hard: values above the knee are set to the knee
- `rate` (number): Soft mode, required there: steepness of the exponential compression
- `view_id` (string, required): Target view to clamp (modified in place)

### `run_wbpp` (~550 tokens)

Start WeightedBatchPreprocessing (WBPP) headless in a separate PixInsight instance (PixInsight -n --automation-mode --force-exit) over input_dirs, writing into output_dir, and return a run id at once; wbpp_status reports the run. output_dir must lie inside <workspace>/output (a relative path is resolved there) or the state folder. Only the WBPP parameters given are passed; WBPP's own settings apply to the rest. Interactive local normalization and frame selection are turned off so nothing waits for a click. optimize_darks and drizzle_scale are applied to every light group by a generated pipeline-builder script. extra_params passes further WBPP automation parameters by name (BPP-Automation.js lists them). Refuses while the GUI instance runs a command for this workspace, and while an earlier run_wbpp run of this workspace is running. Tools that use the GUI instance keep working while WBPP runs.

Input parameters:

- `autocrop` (boolean): WBPP autocrop
- `distortion_correction` (boolean): WBPP distortionCorrection
- `drizzle_scale` (number): Enable drizzle on every light group at this scale
- `extra_params` (object): Further WBPP automation parameters, {name: value}
- `frame_selection` (array): Frame selection filters [{metric, value, compare}], compare less or greater (non-interactive)
- `generate_rejection_maps` (boolean): WBPP generateRejectionMaps
- `image_registration` (boolean): WBPP imageRegistration
- `input_dirs` (array, required): Folders WBPP scans recursively for lights, darks, flats and bias (WBPP dir=)
- `integrate` (boolean): WBPP integrate
- `keywords` (array): Grouping keywords [{name, mode}], mode pre (calibration groups), post (integration groups) or prepost
- `local_normalization` (boolean): WBPP localNormalization (run non-interactively)
- `optimize_darks` (boolean): Set dark optimization on every light group
- `output_dir` (string, required): WBPP output folder: relative to <workspace>/output, or absolute inside <workspace>/output or the state folder
- `plate_solve` (boolean): WBPP platesolve
- `reference` (string): Automatic registration reference: one for all (auto) or one per value of reference_keyword
- `reference_image` (string): Registration reference image file (WBPP referenceImage, manual reference)
- `reference_keyword` (string): Keyword for reference auto_by_keyword
- `rejection` (string): Pixel rejection for lights (WBPP rejection_4)
- `weights` (string): Subframe weighting method, or none

### `wbpp_status` (~140 tokens)

Report a run_wbpp run: running, finished (with the PixInsight exit code) or ended without an exit record; the master files in <output_dir>/master; the number of .xisf files in each subfolder of <output_dir>/registered and <output_dir>/calibrated; the WBPP log files in <output_dir>/logs; and the last lines of the instance's console output. run_id omitted: the latest run.

Input parameters:

- `run_id` (string): Run id from run_wbpp (default: the latest run)
- `tail_lines` (integer): Console-output lines to include (default 30)

### `scan_workspace` (~132 tokens)

Scan the working folder (recursively, any subfolder name) for XISF/FITS files and report each one's FILTER header value, geometry, exposure, whether it has an astrometric solution (WCS keywords CTYPE/CRVAL with a CD, CDELT or PC matrix, or PixInsight's PCL:AstrometricSolution properties), and its INSTRUME, TELESCOP, FOCALLEN, XPIXSZ, YPIXSZ and XBINNING keywords verbatim (null when absent). The connector's own state and output folders are not scanned. Read-only.

### `workspace_info` (~66 tokens)

Report the workspace folder, the state directories under it (scratch, bridge, logs) and the output folder. Also reports where the folder came from (set_workspace, PIXINSIGHT_CONNECTOR_WORKSPACE or the launch folder) and, when it cannot be used, why. Read-only.

### `set_workspace` (~81 tokens)

Set the workspace folder this session's files go under (scratch files, the bridge, call logs). `path` must name an existing, writable folder, absolute or starting with ~/, other than the filesystem root or the home directory itself. Returns the new workspace_info.

Input parameters:

- `path` (string, required): The folder: an absolute path, or one starting with ~/.

### `resume_bridge` (~32 tokens)

Allow PixInsight commands again after the user pressed Pause/Abort. Call ONLY when the user explicitly tells you to continue.

### `list_packs` (~42 tokens)

List the runtime tool packs discovered at server startup, with load status, tool counts, why any pack was skipped, and which core tools packs replaced. Read-only.

### `job_status` (~151 tokens)

Report on a job started by run_pjsr or run_pjsr_file with `async`: its state (queued, running, ending = stopped in PixInsight with its result not yet collected, done, failed, cancelled, stopped), elapsed time, seconds since the running script last called processEvents(), its latest mcpProgress() text, and, once it has ended, its result or error and PixInsight console errors. Without job_id: the running job, else the most recent one. Read-only; it does not use PixInsight, so it answers while a job runs.

Input parameters:

- `job_id` (string): The id run_pjsr returned. Omit for the running or most recent job.

### `cancel_job` (~137 tokens)

Stop a job started by run_pjsr or run_pjsr_file with `async`. A job PixInsight has not started yet is removed and never runs. A running job is stopped at its next processEvents() call, where an error with MCP_CANCELLED ends the script; a native process call (a single long process, a file save) cannot be interrupted, so the stop takes effect after it returns, and what the script already changed stays changed. Without job_id: the running job. job_status reports the outcome.

Input parameters:

- `job_id` (string): The id run_pjsr returned. Omit for the running job.

## Diagnostics

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

## Score history

- 2026-10-16: 88
- 2026-10-15: 88
- 2026-10-14: 87
- 2026-10-13: 87
- 2026-10-12: 86
- 2026-10-11: 86
- 2026-10-04: 83
- 2026-10-03: 82
- 2026-10-02: 82
- 2026-10-01: 81
- 2026-09-30: 66
- 2026-09-29: 81
- 2026-09-28: 65
- 2026-09-27: 80
- 2026-09-26: 79
- 2026-09-25: 79
- 2026-09-24: 53

## Common questions

### What is the PixInsight Connector MCP server?

PixInsight Connector is an MCP server listed in the public MCP registry as io.github.mxcoppell/pixinsight-connector. Operate PixInsight from any MCP agent. Community project, not affiliated with Pleiades Astrophoto. This page covers its npm package (pixinsight-connector).

### Is the PixInsight Connector MCP server safe to use?

PixInsight Connector scores 88 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 16 October 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 PixInsight Connector MCP server expose?

PixInsight Connector exposes 91 tools: align_files, verify_astrometry, run_plate_solve, copy_astrometric_solution, catalog_stars, and 86 more. Their descriptions and schemas cost roughly 17,602 tokens of context every time the server is loaded.

### Is the PixInsight Connector MCP server still maintained?

PixInsight Connector is still listed as active in the MCP registry. We last reached this channel on 16 October 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 PixInsight Connector MCP server under?

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

## Links

- npm package: https://www.npmjs.com/package/pixinsight-connector
- Socket report: https://socket.dev/npm/package/pixinsight-connector
- Repository: https://github.com/mxcoppell/pixinsight-connector
- Changelog RSS feed: https://verifymcp.io/servers/mxcoppell-pixinsight-connector/pixinsight-connector.xml
- Changelog JSON feed: https://verifymcp.io/servers/mxcoppell-pixinsight-connector/pixinsight-connector.json
- HTML version of this page: https://verifymcp.io/servers/mxcoppell-pixinsight-connector/pixinsight-connector