editmamei 1.9.6 → 1.9.7

package/dist/backends/gimp/bridge/ops.py

@@ -128,10 +128,75 @@ def _describe(img):
         'height': img.get_height(),
         'base_type': img.get_base_type().value_nick,
         'precision': img.get_precision().value_nick,
+        'color_profile': _color_profile_info(img),
         'layers': [l.get_name() for l in img.get_layers()],
     }
 
 
+def _profile_texts(profile):
+    """[description, manufacturer, model, copyright], each None when unreadable: positions are
+    fixed, since `lib.classify_color_profile` ignores the copyright by position."""
+    texts = []
+    for getter in ('get_description', 'get_manufacturer', 'get_model', 'get_copyright'):
+        try:
+            texts.append(getattr(profile, getter)())
+        except Exception:
+            texts.append(None)
+    return texts
+
+
+def _color_profile_info(img):
+    """The image's color space as results report it: `space` (lib.classify_color_profile),
+    `name` (the profile's own description, None for the built-in sRGB or a profile the editor
+    made, whose internal name says nothing useful), and `wide_gamut` (True when the space holds
+    colors sRGB cannot show, so it must travel with the file)."""
+    profile = img.get_color_profile()
+    texts = None if profile is None else _profile_texts(profile)
+    space = lib.classify_color_profile(texts, grayscale=img.get_base_type() == Gimp.ImageBaseType.GRAY)
+    name = None
+    if texts is not None and not lib.profile_is_editors_own(texts):
+        name = next((t for t in texts[:3] if t), None)
+    return {'space': space, 'name': name, 'wide_gamut': space in lib.WIDE_GAMUT_SPACES}
+
+
+def _builtin_profile_for(img):
+    if img.get_base_type() == Gimp.ImageBaseType.GRAY:
+        return Gimp.ColorProfile.new_d65_gray_srgb_trc()
+    return Gimp.ColorProfile.new_rgb_srgb()
+
+
+def _has_builtin_profile(img):
+    """Whether `img` is in the editor's built-in sRGB (or gray with the sRGB curve): no profile of
+    its own, or one identical to it. Such an image is written untagged, which every viewer reads
+    as sRGB. Anything else is written WITH its profile, or its colors would be read as sRGB."""
+    profile = img.get_color_profile()
+    return profile is None or profile.is_equal(_builtin_profile_for(img))
+
+
+def _apply_color_profile(dup, target):
+    """Convert `dup` in place for an export `color_profile` target (lib.COLOR_PROFILE_TARGETS).
+    Returns the space it was converted FROM, or None when nothing changed ('keep', or already in
+    the target space)."""
+    if target == 'keep':
+        return None
+    gray = dup.get_base_type() == Gimp.ImageBaseType.GRAY
+    if target == 'srgb':
+        dest = _builtin_profile_for(dup)
+    elif gray:
+        raise ValueError("color_profile %r needs an RGB image; this one is grayscale" % target)
+    else:
+        dest = Gimp.ColorProfile.new_rgb_adobe()
+    current = dup.get_color_profile() or _builtin_profile_for(dup)
+    if current.is_equal(dest):
+        return None
+    before = _color_profile_info(dup)['space']
+    if not dup.convert_color_profile(dest, Gimp.ColorRenderingIntent.RELATIVE_COLORIMETRIC, True):
+        raise lib.OpError('gimp_op_failed', 'could not convert the image to %s' % target)
+    # A file's own sRGB (or gray) profile converted to the built-in one is a re-tag, not a change
+    # of space worth reporting.
+    return None if before == _color_profile_info(dup)['space'] else before
+
+
 def _existing_filter(img, args, operation):
     """Look up filter_id AMONG img's own layers -- not just by a global id
     lookup, which would happily hand back a filter that belongs to some
@@ -1677,6 +1742,8 @@ def op_filter(args):
         f.set_visible(visible)
         return {'filter_id': f.get_id(), 'visible': visible}
     if fop == 'delete':
+        if args.get('filter_ids') is not None:
+            return _delete_filters_by_id(img, args.get('filter_ids'))
         filter_id = int(lib.require(args, 'filter_id'))
         layer, f = _find_filter(img, filter_id)
         name = f.get_name()
@@ -1696,6 +1763,43 @@ def op_filter(args):
     raise ValueError('op must be one of list, set_visibility, delete (got %r)' % fop)
 
 
+FILTER_IDS_MAX = 100
+
+
+def _delete_filters_by_id(img, raw_ids):
+    """`filter` op=delete with `filter_ids`: several filters in one call. Every id is looked up
+    first, so an unknown id (or a repeat) refuses the whole call with nothing deleted; then each is
+    deleted and the ledger is rewritten once."""
+    if not isinstance(raw_ids, list) or not raw_ids:
+        raise ValueError('filter_ids must be a non-empty list of filter ids')
+    if len(raw_ids) > FILTER_IDS_MAX:
+        raise ValueError('filter_ids takes at most %d ids per call' % FILTER_IDS_MAX)
+    ids = []
+    for raw in raw_ids:
+        if isinstance(raw, bool) or not isinstance(raw, int):
+            raise ValueError('filter_ids must hold integer filter ids (got %r)' % (raw,))
+        if raw in ids:
+            raise ValueError('filter %s is named twice in filter_ids' % raw)
+        ids.append(raw)
+    found = [(fid,) + _find_filter(img, fid) for fid in ids]
+    names = set()
+    deleted = []
+    try:
+        for fid, _layer, f in found:
+            name = f.get_name()
+            f.delete()
+            names.add(name)
+            deleted.append({'filter_id': fid, 'name': name})
+    finally:
+        # Whatever was deleted leaves the ledger too, even when a later delete fails.
+        if names:
+            filters, unknown = _ledger_get(img)
+            for name in names:
+                filters.pop(name, None)
+            _ledger_put(img, filters, unknown, removed=names)
+    return {'filter_ids': ids, 'filters': deleted, 'deleted': True}
+
+
 DESCRIBE_TARGETS = ('document', 'layers', 'channels', 'filter')
 
 # A hard cap on how many layer-tree nodes `describe`'s `document`/`layers` targets will build,
@@ -1869,6 +1973,7 @@ def op_describe(args):
         'height': img.get_height(),
         'base_type': img.get_base_type().value_nick,
         'precision': img.get_precision().value_nick,
+        'color_profile': _color_profile_info(img),
         'resolution': {'x': xres, 'y': yres} if ok else {'x': None, 'y': None},
         'layers': layers,
         'truncated': truncated,
@@ -2536,7 +2641,7 @@ def _strip_metadata(cfg, fmt):
         cfg.set_property(name, False)
 
 
-def _export_stripped(dup, path, options=None):
+def _export_stripped(dup, path, options=None, color_profile='srgb'):
     """The ONE place any flattened raster copy leaves the bridge -- `export`'s own flat branch,
     every `preview` (whole-image or region), and `compare`'s before/after outputs all go through
     this, so there is exactly one spot that decides how metadata is handled and what formats are
@@ -2558,7 +2663,14 @@ def _export_stripped(dup, path, options=None):
     Bit depth: png/tiff accept `bit_depth: 8 | 16` (default 8); jpeg/webp are always 8-bit. Either
     way `dup`'s precision is converted to match BEFORE saving -- after a 16/32-bit `precision`
     promotion at open time, the flattened duplicate would otherwise still carry that higher bit
-    depth into an export that never asked for it."""
+    depth into an export that never asked for it.
+
+    Color profile: `color_profile` (lib.COLOR_PROFILE_TARGETS) converts `dup` first; previews and
+    compare images pass 'srgb', since they are looked at by viewers and models that may not color
+    manage. The profile is then written unless it is the built-in sRGB. Every export procedure's
+    `include-color-profile` defaults to False when run non-interactively (verified live, GIMP
+    3.2.6), so it is always set explicitly: left alone, a Display P3 photo is written untagged and
+    its colors read as sRGB, visibly duller. Returns the written profile, as results report it."""
     options = options or {}
     ext = os.path.splitext(path)[1].lower()
     fmt = lib.EXPORT_FORMATS.get(ext)
@@ -2566,6 +2678,7 @@ def _export_stripped(dup, path, options=None):
         raise ValueError(
             'export path must end in .jpg, .jpeg, .png, .webp, .tif, or .tiff (got %r)' % ext
         )
+    converted_from = _apply_color_profile(dup, color_profile)
     _export_precision(dup, options if fmt in ('png', 'tiff') else {})
     try:
         dup.set_metadata(Gimp.Metadata.new())
@@ -2598,24 +2711,17 @@ def _export_stripped(dup, path, options=None):
     cfg.set_property('image', dup)
     cfg.set_property('file', Gio.File.new_for_path(path))
     _strip_metadata(cfg, fmt)
-    if _has_editors_profile(dup):
-        cfg.set_property('include-color-profile', False)
+    embedded = not _has_builtin_profile(dup)
+    cfg.set_property('include-color-profile', embedded)
     _run_export(proc, cfg, path)
+    return _written_profile(dup, embedded, converted_from)
 
 
-def _has_editors_profile(img):
-    """Whether `img` carries the editor's built-in color profile (or none of its own), which
-    exports leave out: see `lib.profile_is_editors_own`."""
-    profile = img.get_color_profile()
-    if profile is None:
-        return lib.profile_is_editors_own(None)
-    texts = []
-    for getter in ('get_description', 'get_manufacturer', 'get_model', 'get_copyright'):
-        try:
-            texts.append(getattr(profile, getter)())
-        except Exception:
-            pass
-    return lib.profile_is_editors_own(texts)
+def _written_profile(dup, embedded, converted_from):
+    info = _color_profile_info(dup)
+    info['embedded'] = embedded
+    info['converted_from'] = converted_from
+    return info
 
 
 def _drop_psd_resource(path, resource_id):
@@ -2715,6 +2821,7 @@ def _export_layered(img, path, options):
             group = Gimp.Layer.get_by_id(group_id)
             merged_groups.append(group.get_name())
             group.merge()
+        converted_from = _apply_color_profile(dup, options.get('color_profile', 'keep'))
         _export_precision(dup, options)
         try:
             dup.set_metadata(Gimp.Metadata.new())
@@ -2728,8 +2835,10 @@ def _export_layered(img, path, options):
         _strip_metadata(cfg, 'psd')
         _run_export(proc, cfg, path)
         # file-psd-export writes the profile whatever include-color-profile says (verified live,
-        # GIMP 3.2.6), so the editor's own is taken out of the written file instead.
-        if _has_editors_profile(dup):
+        # GIMP 3.2.6), so the built-in sRGB is taken out of the written file instead: an untagged
+        # file reads as sRGB anyway.
+        embedded = not _has_builtin_profile(dup)
+        if not embedded:
             _drop_psd_resource(path, lib.PSD_ICC_RESOURCE)
 
         final = _all_layers(dup)
@@ -2742,6 +2851,7 @@ def _export_layered(img, path, options):
             'merged_groups': merged_groups,
             'rasterized_text': rasterized_text,
             'may_blend_differently': may_blend_differently,
+            'color_profile': _written_profile(dup, embedded, converted_from),
         }
     finally:
         dup.delete()
@@ -2764,6 +2874,14 @@ def op_export(args):
     img = _image(args)
     path = lib.require(args, 'path')
     keep_alpha = lib.validate_keep_alpha(args, path)
+    color_profile = lib.validate_choice(
+        'color_profile', args.get('color_profile', 'keep'), lib.COLOR_PROFILE_TARGETS
+    )
+    # Refused before the full-resolution render, not after it.
+    if color_profile == 'adobe-rgb' and img.get_base_type() == Gimp.ImageBaseType.GRAY:
+        raise ValueError("color_profile 'adobe-rgb' needs an RGB image; this one is grayscale")
+    if path.lower().endswith('.xcf') and color_profile != 'keep':
+        raise ValueError(".xcf saves the working document as it is; color_profile must be 'keep'")
     if path.lower().endswith('.xcf'):
         # file_save reports a failed write by returning False, not by raising (verified live).
         if not Gimp.file_save(Gimp.RunMode.NONINTERACTIVE, img, Gio.File.new_for_path(path), None):
@@ -2773,7 +2891,7 @@ def op_export(args):
                 % os.path.basename(path),
             )
     elif os.path.splitext(path)[1].lower() in lib.LAYERED_EXPORT_FORMATS:
-        report = _export_layered(img, path, args)
+        report = _export_layered(img, path, dict(args, color_profile=color_profile))
         return dict({'path': path, 'bytes': os.path.getsize(path)}, **report)
     else:
         if keep_alpha:
@@ -2786,9 +2904,10 @@ def op_export(args):
         else:
             dup, _flat = _composite(img)
         try:
-            _export_stripped(dup, path, args)
+            written = _export_stripped(dup, path, args, color_profile)
         finally:
             dup.delete()
+        return {'path': path, 'bytes': os.path.getsize(path), 'color_profile': written}
     return {'path': path, 'bytes': os.path.getsize(path)}
 
 

package/dist/cli/config.js

@@ -1,4 +1,4 @@
-import { loadSettings, saveSettings, } from '../core/settings.js';
+import { loadSettings, saveSettings, setFeatureDetails, } from '../core/settings.js';
 import { requireAbsoluteGimpPath } from '../utils/tool-helpers.js';
 function coerceBool(raw) {
     const v = raw.trim().toLowerCase();
@@ -40,6 +40,13 @@ const KEYS = {
         },
         coerce: coerceBool,
     },
+    'telemetry.features': {
+        get: (s) => s.telemetry.features ?? 'not asked (off)',
+        set: (s, v) => {
+            setFeatureDetails(s, v, 'cli');
+        },
+        coerce: coerceBool,
+    },
     'telemetry.install_id': {
         get: (s) => s.telemetry.install_id,
     },

package/dist/core/consent-questions.js

@@ -0,0 +1,6 @@
+export const FEATURES_QUESTION = {
+    id: 'features',
+    version: 1,
+    message: 'Share the names of editing features Editmamei uses? No files, text or scripts are sent. ' +
+        'You can change this in settings.',
+};

package/dist/core/consent.js

@@ -0,0 +1,130 @@
+import { SdkErrorCode } from '@modelcontextprotocol/server';
+import { Logger } from '../utils/logger.js';
+import { FEATURES_QUESTION } from './consent-questions.js';
+import { loadSettings, saveSettings, setFeatureDetails, } from './settings.js';
+const logger = new Logger('Consent');
+const PROMPT_TIMEOUT_MS = 5 * 60_000;
+export const MAX_DISMISSALS = 3;
+export function clientSupportsForm(elicitation) {
+    if (typeof elicitation !== 'object' || elicitation === null)
+        return false;
+    const caps = elicitation;
+    return caps.form != null || caps.url == null;
+}
+export function shouldAsk(settings) {
+    if (!settings.telemetry.usage)
+        return false;
+    if (settings.desktop_toggles?.features === false)
+        return false;
+    const record = settings.consent?.features;
+    if (record) {
+        if (record.version >= FEATURES_QUESTION.version)
+            return false;
+    }
+    else if (settings.telemetry.features !== undefined) {
+        return false;
+    }
+    const dismissals = settings.consent_dismissals?.features;
+    return !(dismissals &&
+        dismissals.version === FEATURES_QUESTION.version &&
+        dismissals.count >= MAX_DISMISSALS);
+}
+export async function runConsentPrompt(deps) {
+    try {
+        if (deps.degraded || !deps.telemetryActive)
+            return;
+        await reportUnsentAnswer(deps);
+        if (!shouldAsk(deps.settings))
+            return;
+        if (!deps.supportsForm) {
+            await reportOutcome(deps, 'unsupported');
+            return;
+        }
+        const outcome = await ask(deps);
+        if (outcome === 'accepted' || outcome === 'declined') {
+            storeAnswer(deps, outcome === 'accepted');
+            await reportUnsentAnswer(deps);
+            return;
+        }
+        if (outcome === 'dismissed' || outcome === 'timed_out')
+            storeDismissal(deps);
+        await reportOutcome(deps, outcome);
+    }
+    catch (err) {
+        logger.debug(`consent prompt skipped: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+async function ask(deps) {
+    try {
+        const answer = await deps.elicit({
+            message: FEATURES_QUESTION.message,
+            requestedSchema: {
+                type: 'object',
+                properties: {
+                    share: { type: 'boolean', title: 'Share feature names', default: false },
+                },
+                required: ['share'],
+            },
+        }, { timeout: PROMPT_TIMEOUT_MS });
+        if (answer.action === 'accept')
+            return answer.content?.share === true ? 'accepted' : 'declined';
+        return answer.action === 'decline' ? 'declined' : 'dismissed';
+    }
+    catch (err) {
+        return err?.code === SdkErrorCode.RequestTimeout
+            ? 'timed_out'
+            : 'failed';
+    }
+}
+async function reportOutcome(deps, result) {
+    await deps.report({
+        question: FEATURES_QUESTION.id,
+        questionVersion: FEATURES_QUESTION.version,
+        result,
+        via: 'elicitation',
+    });
+}
+function update(deps, mutate) {
+    mutate(deps.settings);
+    const { settings: onDisk, degraded } = loadSettings(deps.storage);
+    if (degraded)
+        return;
+    mutate(onDisk);
+    saveSettings(onDisk, deps.storage);
+}
+function storeAnswer(deps, share) {
+    update(deps, (settings) => setFeatureDetails(settings, share, 'elicitation', deps.now?.()));
+}
+function storeDismissal(deps) {
+    update(deps, (settings) => {
+        const current = settings.consent_dismissals?.features;
+        const count = current?.version === FEATURES_QUESTION.version ? current.count : 0;
+        settings.consent_dismissals = {
+            features: { version: FEATURES_QUESTION.version, count: count + 1 },
+        };
+    });
+}
+const MAX_QUESTION_VERSION = 1000;
+async function reportUnsentAnswer(deps) {
+    const record = deps.settings.consent?.features;
+    if (!record || record.reported || !deps.settings.telemetry.usage)
+        return;
+    if (record.version < 1 || record.version > MAX_QUESTION_VERSION)
+        return;
+    const settled = await deps.report({
+        question: FEATURES_QUESTION.id,
+        questionVersion: record.version,
+        result: record.answer,
+        via: record.via,
+    });
+    if (!settled)
+        return;
+    update(deps, (settings) => {
+        const stored = settings.consent?.features;
+        if (stored?.version === record.version &&
+            stored.answer === record.answer &&
+            stored.via === record.via) {
+            settings.consent = { ...settings.consent, features: { ...stored, reported: true } };
+        }
+    });
+}

package/dist/core/server.js

@@ -1,6 +1,5 @@
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { Server, CLIENT_CAPABILITIES_META_KEY, CLIENT_INFO_META_KEY, } from '@modelcontextprotocol/server';
+import { serveStdio, StdioServerTransport } from '@modelcontextprotocol/server/stdio';
 import { Logger } from '../utils/logger.js';
 import { ToolRegistry } from './tool-registry.js';
 import { tierOf } from './tool-tiers.js';
@@ -11,9 +10,11 @@ import { EDITION } from '../edition.js';
 import { VERSION } from '../version.js';
 import { Session } from './session.js';
 import { SessionLog, classifyError, computeResultBytes, NO_ERROR_TEXT_CLASS, } from '../utils/session-log.js';
-import { loadSettings, applyTelemetryEnvOverrides, applyUpdateCheckEnvOverride, } from './settings.js';
+import { loadSettings, applyDesktopToggles } from './settings.js';
 import { itemsFromResult } from '../telemetry/activity.js';
+import { clientSupportsForm, runConsentPrompt } from './consent.js';
 import { TelemetryClient } from '../telemetry/client.js';
+import { callFeatures } from '../telemetry/script-operations.js';
 import { resolveInstallChannel } from '../install-channel.js';
 import { checkForUpdateWithStatus, shouldCheckForUpdate, } from '../update/check.js';
 import { previousSessionFailureCounts, relevantFixes } from '../update/session-fixes.js';
@@ -62,12 +63,13 @@ function hashRetryKey(tool, args) {
 export const FIRST_RUN_DISCLOSURE = 'First run: Editmamei collects content-free usage telemetry (tool name, ' +
     'success, duration, bytes returned, version/edition/OS/PS-version, install channel, ' +
     'which AI client connected, Node/OS/architecture versions, and per-session counts like ' +
-    'edits made and retries) to find what breaks. Usage telemetry never sends image content, ' +
-    'file paths, or tool arguments. The only identifier is a random install ID. Opt out ' +
-    'anytime: `editmamei config set telemetry.usage false` (or edit ' +
-    '~/.editmamei/settings.json). Opt in to sanitized diagnostics (error messages, which can ' +
-    'name a layer or repeat a value you passed): ' +
-    '`editmamei config set telemetry.diagnostics true`.';
+    'edits made and retries) to find what breaks. It also sends the names of editing features and ' +
+    'tool options used, from fixed lists. It never sends image content, file paths, script text, or other ' +
+    'free-form text. The only identifier is a random install ID. Opt out anytime: ' +
+    '`editmamei config set telemetry.usage false` (or edit ~/.editmamei/settings.json), or ' +
+    '`editmamei config set telemetry.features false` for feature names alone. Opt in to ' +
+    'sanitized diagnostics (error messages, which can name a layer or repeat a value you ' +
+    'passed): `editmamei config set telemetry.diagnostics true`.';
 export const BACKGROUND_VERSION_PROBE_TIMEOUT_MS = 3_000;
 const PING_ROUND_TRIP_CLASSES = new Set([
     'timeout',
@@ -78,12 +80,18 @@ const PING_ROUND_TRIP_CLASSES = new Set([
 ]);
 const PHOTOSHOP_PATH_DOCS_URL = 'https://github.com/editmamei/editmamei/blob/main/docs/installation.md#optional-pin-a-specific-photoshop-install';
 export class EditmameiServer {
-    server;
+    clientInfo = () => undefined;
+    clientConnectedSent = false;
+    consent = {
+        settings: {},
+        degraded: true,
+    };
     logger;
     toolRegistry;
     session;
     sessionLog;
     telemetry;
+    lastFeatureCall = null;
     editorOpts;
     gimpBackend;
     lastLoggedGimpVersion;
@@ -128,8 +136,8 @@ export class EditmameiServer {
         this.session = new Session();
         this.sessionLog = new SessionLog(this.session.getSessionId());
         this.logger.info(`Session ${this.session.getSessionId()} → ${this.sessionLog.path}`);
-        const { settings, created } = loadSettings();
-        const effectiveSettings = applyUpdateCheckEnvOverride(applyTelemetryEnvOverrides(settings));
+        const { settings, created, degraded } = loadSettings();
+        const effectiveSettings = applyDesktopToggles(settings, process.env, { persist: !degraded });
         this.telemetry = new TelemetryClient({
             settings: effectiveSettings,
             getPsVersion: () => this.psVersion,
@@ -216,33 +224,13 @@ export class EditmameiServer {
                         ...(this.lastDocMode !== null ? { doc_mode: this.lastDocMode } : {}),
                     });
                 }
+                const previousCall = this.lastFeatureCall;
+                this.lastFeatureCall = { tool: entry.tool, success: telemetrySuccess };
+                this.telemetry.recordFeatures(() => callFeatures(entry.tool, this.toolRegistry.get(entry.tool)?.tool.inputSchema, entry.args, previousCall));
             },
         });
-        this.server = new Server({
-            name: 'editmamei',
-            version: VERSION,
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
-        const srv = this.server;
-        this.sessionLog.setMcpClientGetter(() => srv.getClientVersion?.() ?? null);
-        let clientConnectedSent = false;
-        this.server.oninitialized = () => {
-            if (clientConnectedSent)
-                return;
-            clientConnectedSent = true;
-            const clientInfo = this.server.getClientVersion();
-            const caps = this.server.getClientCapabilities();
-            this.telemetry.recordClientConnected({
-                clientName: clientInfo?.name,
-                clientVersion: clientInfo?.version,
-                capSampling: caps?.sampling != null,
-                capElicitation: caps?.elicitation != null,
-                capRoots: caps?.roots != null,
-            });
-        };
+        this.sessionLog.setMcpClientGetter(() => this.clientInfo() ?? null);
+        this.consent = { settings: effectiveSettings, degraded: degraded === true };
         this.licenseAdvisorySource =
             opts.licenseAdvisory ??
                 ((advisoryOpts) => {
@@ -251,7 +239,6 @@ export class EditmameiServer {
                     return licenseAdvisory(advisoryOpts);
                 });
         this.registerTools();
-        this.setupHandlers();
     }
     buildLicenseAdvisoryNote() {
         if (this.licenseAdvisoryShown)
@@ -441,18 +428,67 @@ export class EditmameiServer {
             },
         };
     }
-    setupHandlers() {
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            this.logger.debug('Reporting the registered tool surface');
-            return {
-                tools: this.toolRegistry.list(),
+    buildServer(era) {
+        const server = new Server({
+            name: 'editmamei',
+            version: VERSION,
+        }, { capabilities: { tools: {} } });
+        if (era === 'legacy') {
+            this.clientInfo = () => server.getClientVersion();
+            server.oninitialized = () => {
+                const info = server.getClientVersion();
+                const caps = server.getClientCapabilities();
+                if (!this.recordClientConnected(info, caps))
+                    return;
+                void runConsentPrompt({
+                    settings: this.consent.settings,
+                    degraded: this.consent.degraded,
+                    telemetryActive: this.telemetry.isActive(),
+                    supportsForm: clientSupportsForm(caps?.elicitation),
+                    elicit: (params, options) => server.elicitInput(params, options),
+                    report: (outcome) => this.telemetry.recordConsentResult({ clientName: info?.name, ...outcome }),
+                });
             };
+        }
+        server.setRequestHandler('tools/list', async (_request, ctx) => {
+            if (era === 'modern')
+                this.noteModernClient(ctx.mcpReq.envelope);
+            this.logger.debug('Reporting the registered tool surface');
+            return { tools: this.toolRegistry.list() };
         });
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        server.setRequestHandler('tools/call', async (request, ctx) => {
+            if (era === 'modern')
+                this.noteModernClient(ctx.mcpReq.envelope);
             this.logger.debug(`Received a call for ${request.params.name}`);
             const args = request.params.arguments || {};
-            return this.handleToolCall(request.params.name, args);
+            const result = await this.handleToolCall(request.params.name, args);
+            const outputSchema = this.toolRegistry.get(request.params.name)?.tool.outputSchema;
+            return server.projectCallToolResult(result, outputSchema);
         });
+        return server;
+    }
+    noteModernClient(envelope) {
+        if (envelope === undefined || this.clientConnectedSent)
+            return;
+        const info = envelope[CLIENT_INFO_META_KEY];
+        const caps = envelope[CLIENT_CAPABILITIES_META_KEY];
+        if (info === undefined && caps === undefined)
+            return;
+        this.clientInfo = () => info;
+        this.recordClientConnected(info, caps);
+    }
+    recordClientConnected(info, caps) {
+        if (this.clientConnectedSent)
+            return false;
+        this.clientConnectedSent = true;
+        this.telemetry.recordClientConnected({
+            clientName: info?.name,
+            clientVersion: info?.version,
+            capSampling: caps?.sampling != null,
+            capElicitation: caps?.elicitation != null,
+            capRoots: caps?.roots != null,
+        });
+        return true;
     }
     async handleToolCall(name, args) {
         try {
@@ -761,8 +797,7 @@ export class EditmameiServer {
     }
     async start() {
         await this.loadModules();
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
+        this.serve(new StdioServerTransport());
         if (this.editorOpts.registerPhotoshop) {
             void this.session.initialize().catch(() => undefined);
             void this.reprovisionIfModuleSkipped();
@@ -770,13 +805,32 @@ export class EditmameiServer {
         }
         this.telemetry.start();
         void this.telemetry.flushOutboxOnStartup();
-        this.server.onclose = () => {
-            void this.telemetry.shutdown();
-            if (this.gimpBackend)
-                void this.gimpBackend.shutdown();
-        };
         this.logger.info('Editmamei is listening on stdio');
     }
+    serve(wire) {
+        serveStdio(({ era }) => this.buildServer(era), {
+            transport: wire,
+            onerror: (error) => this.logger.debug(`MCP connection: ${error.message}`),
+        });
+        const entryOnClose = wire.onclose;
+        let gone = false;
+        wire.onclose = () => {
+            try {
+                entryOnClose?.();
+            }
+            finally {
+                if (!gone) {
+                    gone = true;
+                    this.onClientGone();
+                }
+            }
+        };
+    }
+    onClientGone() {
+        void this.telemetry.shutdown();
+        if (this.gimpBackend)
+            void this.gimpBackend.shutdown();
+    }
     async stop() {
         await this.telemetry.shutdown();
         if (this.gimpBackend)