editmamei 1.7.1 → 1.8.0

package/dist/tools/gimp-text-tools.js

@@ -0,0 +1,181 @@
+import { validateArgs } from '../utils/validate.js';
+import { toolGimpErrorResult } from '../utils/tool-helpers.js';
+import { GIMP_IMAGE_PROP, GIMP_LAYER_ID_PROP, GIMP_LAYER_PROP, pickSchemaDeclaredKeys, } from './gimp-shared.js';
+const TEXT_OPS = ['create', 'set_content', 'set_font', 'set_color', 'set_alignment'];
+const ALIGNMENTS = [
+    'LEFT',
+    'CENTER',
+    'RIGHT',
+    'FULLYJUSTIFIED',
+    'LEFTJUSTIFIED',
+    'CENTERJUSTIFIED',
+    'RIGHTJUSTIFIED',
+];
+const textSchema = {
+    type: 'object',
+    properties: {
+        image: GIMP_IMAGE_PROP,
+        op: {
+            type: 'string',
+            enum: [...TEXT_OPS],
+            description: 'create: a new text layer at the top of the stack with `text` at `x`/`y` (default ' +
+                '100,100) and `font_size` (default 24), optionally with font_name, red/green/blue and ' +
+                'alignment. set_content: replace the text with `text`. set_font: set `font_name` ' +
+                '(optionally `font_size`). set_color: set red/green/blue. set_alignment: set ' +
+                '`alignment`. The set_* ops act on the text layer named by `layer_id` or `layer`.',
+        },
+        layer: {
+            ...GIMP_LAYER_PROP,
+            description: 'set_*: name of the text layer to change. Ignored when layer_id is given. Not used by ' +
+                'create.',
+        },
+        layer_id: {
+            ...GIMP_LAYER_ID_PROP,
+            description: 'set_*: id of the text layer to change (create reports it; gimp_inspect flags text ' +
+                'layers with is_text_layer). Takes priority over `layer`. Not used by create.',
+        },
+        text: {
+            type: 'string',
+            description: 'create: initial text. set_content: the new text, replacing the existing text. At most ' +
+                '2000 characters. For a line break, put a newline character in the string (not a backslash ' +
+                'followed by n).',
+        },
+        x: {
+            type: 'integer',
+            default: 100,
+            description: "create only: the layer's left edge in document pixels.",
+        },
+        y: {
+            type: 'integer',
+            default: 100,
+            description: "create only: the layer's top edge in document pixels.",
+        },
+        font_size: {
+            type: 'number',
+            minimum: 1,
+            maximum: 1296,
+            description: 'Font size in points, 1 to 1296, converted to pixels with the image resolution. create: ' +
+                'initial size (default 24). set_font: new size (omit to keep the current size).',
+        },
+        font_name: {
+            type: 'string',
+            description: 'Font family ("Inter", "Open Sans") or full name ("Inter Bold"), case-insensitive. ' +
+                'create: omit for a default sans. A name that matches nothing is refused with the ' +
+                'closest installed names; gimp_inspect what=fonts lists them all.',
+        },
+        red: {
+            type: 'integer',
+            minimum: 0,
+            maximum: 255,
+            description: 'Text colour red, 0-255. red, green and blue go together.',
+        },
+        green: {
+            type: 'integer',
+            minimum: 0,
+            maximum: 255,
+            description: 'Text colour green, 0-255.',
+        },
+        blue: {
+            type: 'integer',
+            minimum: 0,
+            maximum: 255,
+            description: 'Text colour blue, 0-255.',
+        },
+        alignment: {
+            type: 'string',
+            enum: [...ALIGNMENTS],
+            description: 'Text alignment. GIMP supports LEFT, CENTER, RIGHT and FULLYJUSTIFIED; the other ' +
+                'values ps_text accepts (LEFTJUSTIFIED, CENTERJUSTIFIED, RIGHTJUSTIFIED) are refused.',
+        },
+    },
+    required: ['image', 'op'],
+};
+async function gimpText(gimp, rawArgs) {
+    try {
+        const args = validateArgs(textSchema, rawArgs);
+        const result = await gimp.call('text', pickSchemaDeclaredKeys(textSchema, args));
+        const b = result.bounds;
+        const sizing = result.font_size_px !== undefined && result.ppi
+            ? ` = ${result.font_size_px} px at ${result.ppi} ppi`
+            : '';
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Text layer "${result.name}" (id ${result.layer_id}): ${result.font ?? 'unknown font'} ` +
+                        `${result.font_size} pt${sizing}, ${b.width}x${b.height} px at (${b.x}, ${b.y}).`,
+                },
+            ],
+            structuredContent: result,
+        };
+    }
+    catch (error) {
+        return toolGimpErrorResult('Error editing GIMP text layer', error);
+    }
+}
+export function createGimpTextTools(gimp) {
+    return [
+        {
+            tool: {
+                name: 'gimp_text',
+                description: 'Headless GIMP: create a live, editable text layer or restyle one, chosen with `op` ' +
+                    '(create, set_content, set_font, set_color, set_alignment) — the same ops and ' +
+                    'parameters as ps_text. create adds a layer at `x`/`y` with `text`, `font_size` in ' +
+                    'points, and optional font_name, red/green/blue and alignment; it reports layer_id, ' +
+                    'name, bounds, the image ppi and the font size in pixels. The set_* ops change the text layer named by `layer_id` or `layer` ' +
+                    '(a non-text layer is refused). Fonts accept a family ("Inter") or full name ("Inter ' +
+                    'Bold"), case-insensitive; a miss is refused with the closest installed names (list ' +
+                    'them with gimp_inspect what=fonts). Text is capped at 2000 characters, and a layer ' +
+                    'that would render past the size limit is refused and leaves the document unchanged. ' +
+                    'GIMP supports LEFT, CENTER, RIGHT and FULLYJUSTIFIED alignment only. There is no ' +
+                    'undo in this session: gimp_checkpoint or gimp_save_xcf first when in doubt.',
+                inputSchema: textSchema,
+                outputSchema: {
+                    type: 'object',
+                    properties: {
+                        layer_id: { type: 'number' },
+                        name: { type: 'string' },
+                        text: { type: 'string', description: 'Capped at 200 characters for reporting.' },
+                        text_length: { type: 'integer' },
+                        text_truncated: { type: 'boolean' },
+                        has_markup: { type: 'boolean' },
+                        font: { type: ['string', 'null'] },
+                        font_size: { type: 'number', description: 'Points.' },
+                        font_size_px: {
+                            type: 'number',
+                            description: 'The font size in pixels at the image resolution (the height of a line).',
+                        },
+                        ppi: { type: ['number', 'null'], description: "The image's resolution." },
+                        color: {
+                            type: 'object',
+                            properties: {
+                                red: { type: 'number' },
+                                green: { type: 'number' },
+                                blue: { type: 'number' },
+                            },
+                        },
+                        alignment: { type: ['string', 'null'] },
+                        bounds: {
+                            type: 'object',
+                            properties: {
+                                x: { type: ['number', 'null'] },
+                                y: { type: ['number', 'null'] },
+                                width: { type: 'number' },
+                                height: { type: 'number' },
+                            },
+                        },
+                    },
+                },
+                annotations: {
+                    title: 'GIMP Text Layer',
+                    readOnlyHint: false,
+                    destructiveHint: false,
+                    idempotentHint: false,
+                    openWorldHint: true,
+                },
+            },
+            handler: async (args) => gimpText(gimp, args),
+        },
+    ];
+}
+export const TEXT_SCHEMA_FOR_TESTS = textSchema;

package/dist/tools/gimp-transform-layer-tools.js

@@ -0,0 +1,215 @@
+import { validateArgs } from '../utils/validate.js';
+import { toolGimpErrorResult, unknownDiscriminator } from '../utils/tool-helpers.js';
+import { GIMP_IMAGE_PROP, GIMP_LAYER_PROP, GIMP_LAYER_ID_PROP, pickSchemaDeclaredKeys, } from './gimp-shared.js';
+import { EFFECT_UPDATE_FAILURES_PROP, effectUpdateFailuresNote } from './gimp-geometry-tools.js';
+const TRANSFORM_LAYER_OPS = ['fit', 'scale', 'move', 'rotate', 'flip', 'skew', 'free'];
+const xyProp = (what) => ({
+    type: 'object',
+    description: `A document-pixel point: {x, y}. ${what}`,
+    properties: { x: { type: 'number' }, y: { type: 'number' } },
+    required: ['x', 'y'],
+});
+const transformLayerSchema = {
+    type: 'object',
+    properties: {
+        image: GIMP_IMAGE_PROP,
+        layer: {
+            ...GIMP_LAYER_PROP,
+            description: (GIMP_LAYER_PROP.description ?? '') + ' Ignored when layer_id is given.',
+        },
+        layer_id: GIMP_LAYER_ID_PROP,
+        op: {
+            type: 'string',
+            enum: [...TRANSFORM_LAYER_OPS],
+            description: "'fit' scales the layer to fit (letterbox) or fill (cover) the canvas, preserving " +
+                "aspect, and centers it (mode fit|fill, idempotent). 'scale' is uniform (scale_percent) " +
+                'or non-uniform (scale_x_percent/scale_y_percent) — multiplicative, anchored at the ' +
+                "layer's own center; a NON-uniform scale is refused while an unmasked position/" +
+                'direction-dependent effect filter (vignette/motion_blur/drop_shadow) is present. ' +
+                "'move' translates — pass exactly ONE of delta (relative), absolute (top-left target), " +
+                'or center_on (center target), each a {x, y} object (flat delta_x/absolute_x fields are ' +
+                "not accepted); mixing modes is refused. 'rotate' rotates by relative degrees (positive " +
+                "clockwise) around the layer's own center; the layer GROWS to fit the rotated content " +
+                '— nothing is clipped; an arbitrary (non-90°-multiple) angle is refused while such an ' +
+                "effect is present. 'flip' mirrors horizontal|vertical in place (axis). 'skew' slants " +
+                "the layer (skew_h_degrees/skew_v_degrees) around its own center. 'free' is a numeric " +
+                'free transform in one matrix: scale_x_percent/scale_y_percent + degrees + offset_x/' +
+                'offset_y. skew and free are always refused while such an effect is present (no angle ' +
+                'is safe for either). A text layer stays a text layer through every op, never ' +
+                'rasterized.',
+        },
+        mode: {
+            type: 'string',
+            enum: ['fit', 'fill'],
+            description: "fit only. 'fit' letterboxes inside the canvas (shorter edge touches); 'fill' covers it " +
+                '(longer edge touches, overflow is left outside the canvas, not cropped). Defaults to ' +
+                "'fit'.",
+        },
+        scale_percent: {
+            type: 'number',
+            minimum: 1,
+            maximum: 10000,
+            description: 'scale only. Uniform scale percentage (100 = unchanged). 1..10000.',
+        },
+        scale_x_percent: {
+            type: 'number',
+            minimum: 1,
+            maximum: 10000,
+            description: 'scale/free: horizontal scale percentage (100 = unchanged), 1..10000. scale: pair with ' +
+                'scale_y_percent for non-uniform stretch/squash; the other axis defaults to ' +
+                'scale_percent, or 100 if that is absent too.',
+        },
+        scale_y_percent: {
+            type: 'number',
+            minimum: 1,
+            maximum: 10000,
+            description: 'scale/free: vertical scale percentage. See scale_x_percent.',
+        },
+        delta: xyProp("move, RELATIVE mode: offset from the layer's current top-left. Mutually exclusive with absolute/center_on."),
+        absolute: xyProp("move, ABSOLUTE mode: target for the layer's top-left corner. Mutually exclusive with delta/center_on."),
+        center_on: xyProp("move, CENTER mode: target for the layer's center point. Mutually exclusive with delta/absolute."),
+        degrees: {
+            type: 'number',
+            description: "rotate: relative rotation angle, positive clockwise, around the layer's own center. " +
+                'free: relative rotation angle (default 0), applied in the same combined matrix as the ' +
+                'scale and offset.',
+        },
+        axis: {
+            type: 'string',
+            enum: ['horizontal', 'vertical'],
+            description: "flip only. 'horizontal' mirrors left-right; 'vertical' mirrors top-bottom.",
+        },
+        skew_h_degrees: {
+            type: 'number',
+            description: 'skew only. Horizontal slant angle in degrees — positive slants the top edge right. At ' +
+                'least one of skew_h_degrees/skew_v_degrees is required.',
+        },
+        skew_v_degrees: {
+            type: 'number',
+            description: 'skew only. Vertical slant angle in degrees — positive slants the left edge down.',
+        },
+        offset_x: {
+            type: 'number',
+            minimum: -100000,
+            maximum: 100000,
+            description: 'free only. Horizontal translation in document pixels, applied last. Defaults to 0.',
+        },
+        offset_y: {
+            type: 'number',
+            minimum: -100000,
+            maximum: 100000,
+            description: 'free only. Vertical translation in document pixels, applied last. Defaults to 0.',
+        },
+        interpolation: {
+            type: 'string',
+            enum: ['none', 'linear', 'cubic', 'nohalo', 'lohalo'],
+            default: 'cubic',
+            description: 'Resampling filter for this call, every op. Always set explicitly here — never carried ' +
+                'over from a previous gimp_transform_layer call.',
+        },
+    },
+    required: ['image', 'op'],
+};
+function boundsText(result) {
+    const b = result.bounds;
+    return b ? `bounds now (${b.x}, ${b.y}) ${b.width}x${b.height}` : '';
+}
+function alphaNote(result) {
+    return result.alpha_added ? ' (alpha channel added)' : '';
+}
+function effectNote(result) {
+    return effectUpdateFailuresNote(result.effect_update_failures);
+}
+function transformLayerSuccessText(op, result, args) {
+    switch (op) {
+        case 'fit':
+            return (`Layer ${result.mode === 'fill' ? 'filled' : 'fitted'} to the canvas and centered ` +
+                `(${result.scale_percent}%), ${boundsText(result)}${alphaNote(result)}.` +
+                effectNote(result));
+        case 'scale':
+            return (`Layer scaled to ${result.scale_x_percent}% x ${result.scale_y_percent}%, ` +
+                `${boundsText(result)}${alphaNote(result)}.${effectNote(result)}`);
+        case 'move':
+            return `Layer moved, ${boundsText(result)}${alphaNote(result)}.`;
+        case 'rotate':
+            return (`Layer rotated ${result.degrees}°, ${boundsText(result)}${alphaNote(result)}.` +
+                effectNote(result));
+        case 'flip':
+            return (`Layer flipped ${args.axis}, ${boundsText(result)}${alphaNote(result)}.` +
+                effectNote(result));
+        case 'skew':
+            return (`Layer skewed (h=${result.skew_h_degrees ?? 0}°, v=` +
+                `${result.skew_v_degrees ?? 0}°), ${boundsText(result)}${alphaNote(result)}.`);
+        default:
+            return `Layer free-transformed, ${boundsText(result)}${alphaNote(result)}.`;
+    }
+}
+async function gimpTransformLayer(gimp, rawArgs) {
+    try {
+        const args = validateArgs(transformLayerSchema, rawArgs);
+        const op = args.op;
+        if (!TRANSFORM_LAYER_OPS.includes(op)) {
+            return unknownDiscriminator('op', op, TRANSFORM_LAYER_OPS);
+        }
+        const result = await gimp.call('transform_layer', pickSchemaDeclaredKeys(transformLayerSchema, args));
+        return {
+            content: [{ type: 'text', text: transformLayerSuccessText(op, result, args) }],
+            structuredContent: result,
+        };
+    }
+    catch (error) {
+        return toolGimpErrorResult('Error transforming GIMP layer', error);
+    }
+}
+export function createGimpTransformLayerTools(gimp) {
+    return [
+        {
+            tool: {
+                name: 'gimp_transform_layer',
+                description: 'Headless GIMP: transform the active layer (layer/layer_id) — op selects ' +
+                    'fit|scale|move|rotate|flip|skew|free, each documented on op. Rotate/skew/free grow ' +
+                    'the layer so nothing clips; a layer with no alpha gets one (alpha_added). REFUSES ' +
+                    "when the layer, or a group target's descendants, carries a masked filter, or an " +
+                    'unmasked effect this transform cannot keep locked to the content.',
+                inputSchema: transformLayerSchema,
+                outputSchema: {
+                    type: 'object',
+                    properties: {
+                        layer_id: { type: 'number' },
+                        bounds: {
+                            type: 'object',
+                            properties: {
+                                x: { type: ['number', 'null'] },
+                                y: { type: ['number', 'null'] },
+                                width: { type: 'number' },
+                                height: { type: 'number' },
+                            },
+                        },
+                        alpha_added: { type: 'boolean' },
+                        interpolation: { type: 'string' },
+                        text_layer: { type: 'boolean' },
+                        effect_update_failures: EFFECT_UPDATE_FAILURES_PROP,
+                        mode: { type: 'string' },
+                        scale_percent: { type: 'number' },
+                        scale_x_percent: { type: 'number' },
+                        scale_y_percent: { type: 'number' },
+                        degrees: { type: 'number' },
+                        axis: { type: 'string' },
+                        skew_h_degrees: { type: 'number' },
+                        skew_v_degrees: { type: 'number' },
+                        offset_x: { type: 'number' },
+                        offset_y: { type: 'number' },
+                    },
+                },
+                annotations: {
+                    title: 'Transform GIMP Layer',
+                    readOnlyHint: false,
+                    destructiveHint: true,
+                    idempotentHint: false,
+                    openWorldHint: true,
+                },
+            },
+            handler: async (args) => gimpTransformLayer(gimp, args),
+        },
+    ];
+}

package/dist/tools/gimp-verify-tools.js

@@ -1,24 +1,13 @@
 import { randomUUID } from 'node:crypto';
-import { readFile, rm } from 'node:fs/promises';
+import { rm } from 'node:fs/promises';
 import { basename } from 'node:path';
 import { validateArgs } from '../utils/validate.js';
 import { toolGimpErrorResult, unknownDiscriminator } from '../utils/tool-helpers.js';
-import { loadSettings } from '../core/settings.js';
 import { Logger } from '../utils/logger.js';
-import { GimpError } from '../backends/gimp/errors.js';
-import { GIMP_IMAGE_PROP, GIMP_REGION_PROP, GIMP_MAX_PX_PROP, pickSchemaDeclaredKeys, } from './gimp-shared.js';
+import { GIMP_IMAGE_PROP, GIMP_REGION_PROP, GIMP_MAX_PX_PROP, pickSchemaDeclaredKeys, readRender, defaultPreviewsAllowed, } from './gimp-shared.js';
 const logger = new Logger('GimpVerifyTools');
 const CHANNELS = ['luminance', 'red', 'green', 'blue'];
-async function readRender(path) {
-    try {
-        return await readFile(path);
-    }
-    catch {
-        throw new GimpError('gimp_op_failed', 'GIMP reported success but the render was not written');
-    }
-}
 export const HISTOGRAM_BIN_COUNT = 256;
-const defaultPreviewsAllowed = () => loadSettings().settings.privacy.send_previews_to_llm;
 const previewSchema = {
     type: 'object',
     properties: {

package/dist/tools/image-placement-tools.js

@@ -1,4 +1,5 @@
 import { runSnippetTool } from '../utils/tool-helpers.js';
+import { requireLocalPath } from '../utils/local-path.js';
 const PS_COORD_MAX_PX = 300_000;
 const placeImageSchema = {
     type: 'object',
@@ -72,7 +73,11 @@ async function placeImage(connection, snippetClient, rawArgs) {
         snippet: 'placeImage',
         errorPrefix: 'Error placing image',
         params: (args) => {
-            const params = { filePath: args.file_path, x: args.x, y: args.y };
+            const params = {
+                filePath: requireLocalPath('file_path', args.file_path),
+                x: args.x,
+                y: args.y,
+            };
             if (args.width_percent !== undefined)
                 params.widthPercent = args.width_percent;
             if (args.height_percent !== undefined)

package/dist/tools/sky-tools.js

@@ -1,4 +1,5 @@
 import { runSnippetTool } from '../utils/tool-helpers.js';
+import { requireLocalPath } from '../utils/local-path.js';
 import { SKY_REPLACEMENT_TIMEOUT_MS } from '../utils/operation-timeouts.js';
 const PLACEHOLDER_SKY_ID = '00000000-0000-0000-0000-000000000000';
 const replaceSkyInputSchema = {
@@ -75,7 +76,7 @@ async function replaceSky(connection, snippetClient, rawArgs) {
         errorPrefix: 'Error running Sky Replacement',
         timeoutMs: SKY_REPLACEMENT_TIMEOUT_MS,
         params: (args) => ({
-            skyPath: args.sky_file,
+            skyPath: requireLocalPath('sky_file', args.sky_file),
             skyName: args.sky_name ?? 'Custom Sky',
             skyId: PLACEHOLDER_SKY_ID,
             shiftEdge: args.shift_edge ?? 0,

package/dist/utils/gimp-path.js

@@ -1,27 +1,23 @@
 import { win32 as pathWin32, posix as pathPosix } from 'node:path';
 import { GimpError } from '../backends/gimp/errors.js';
-const UNC_OR_DEVICE_PATH_RE = /^[\\/]{2}/;
-const WIN32_DRIVE_ROOTED_RE = /^[A-Za-z]:[\\/]/;
+import { localPathProblem } from './local-path.js';
 export function requireAbsoluteGimpPath(field, value, platform = process.platform) {
-    const pathImpl = platform === 'win32' ? pathWin32 : pathPosix;
-    if (typeof value !== 'string' || value.length === 0) {
-        throw new GimpError('invalid_argument', `"${field}" is required and must be a non-empty string`);
+    switch (localPathProblem(value, platform)) {
+        case undefined:
+            return value;
+        case 'not_string':
+            throw new GimpError('invalid_argument', `"${field}" is required and must be a non-empty string`);
+        case 'unc_or_device':
+            throw new GimpError('invalid_argument', `"${field}" must be a plain local path — UNC shares and \\\\?\\ / \\\\.\\ device paths are ` +
+                `refused, got "${value}". Pass a path on a local drive, e.g. C:/Users/you/photo.jpg.`);
+        case 'relative':
+            throw new GimpError('invalid_argument', `"${field}" must be an absolute path, got "${value}" — pass a full filesystem path, not one relative to a working directory the GIMP session doesn't share.`);
+        case 'no_drive':
+            throw new GimpError('invalid_argument', `"${field}" must include a drive letter, got "${value}" — a path rooted at "\\" alone is ` +
+                `ambiguous about which drive it resolves on. Pass e.g. C:/Users/you/photo.jpg.`);
+        case 'unstable': {
+            const resolved = (platform === 'win32' ? pathWin32 : pathPosix).resolve(value);
+            throw new GimpError('invalid_argument', `"${field}" does not resolve to a stable absolute path ("${value}" -> "${resolved}") — pass a plain, fully-qualified path.`);
+        }
     }
-    if (UNC_OR_DEVICE_PATH_RE.test(value)) {
-        throw new GimpError('invalid_argument', `"${field}" must be a plain local path — UNC shares and \\\\?\\ / \\\\.\\ device paths are ` +
-            `refused, got "${value}". Pass a path on a local drive, e.g. C:/Users/you/photo.jpg.`);
-    }
-    if (!pathImpl.isAbsolute(value)) {
-        throw new GimpError('invalid_argument', `"${field}" must be an absolute path, got "${value}" — pass a full filesystem path, not one relative to a working directory the GIMP session doesn't share.`);
-    }
-    if (platform === 'win32' && !WIN32_DRIVE_ROOTED_RE.test(value)) {
-        throw new GimpError('invalid_argument', `"${field}" must include a drive letter, got "${value}" — a path rooted at "\\" alone is ` +
-            `ambiguous about which drive it resolves on. Pass e.g. C:/Users/you/photo.jpg.`);
-    }
-    const normalizeRoot = (root) => root.replace(/\//g, '\\').toLowerCase();
-    const resolved = pathImpl.resolve(value);
-    if (normalizeRoot(pathImpl.parse(resolved).root) !== normalizeRoot(pathImpl.parse(value).root)) {
-        throw new GimpError('invalid_argument', `"${field}" does not resolve to a stable absolute path ("${value}" -> "${resolved}") — pass a plain, fully-qualified path.`);
-    }
-    return value;
 }

package/dist/utils/local-path.js

@@ -0,0 +1,99 @@
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { win32 as pathWin32, posix as pathPosix } from 'node:path';
+const UNC_OR_DEVICE_PATH_RE = /^[\\/]{2}/;
+const WIN32_DRIVE_ROOTED_RE = /^[A-Za-z]:[\\/]/;
+const HOME_RELATIVE_RE = /^~[\\/]/;
+export function localPathProblem(value, platform = process.platform) {
+    const pathImpl = platform === 'win32' ? pathWin32 : pathPosix;
+    if (typeof value !== 'string' || value.length === 0)
+        return 'not_string';
+    if (UNC_OR_DEVICE_PATH_RE.test(value))
+        return 'unc_or_device';
+    if (!pathImpl.isAbsolute(value))
+        return 'relative';
+    if (platform === 'win32' && !WIN32_DRIVE_ROOTED_RE.test(value))
+        return 'no_drive';
+    const normalizeRoot = (root) => root.replace(/\//g, '\\').toLowerCase();
+    const resolved = pathImpl.resolve(value);
+    if (normalizeRoot(pathImpl.parse(resolved).root) !== normalizeRoot(pathImpl.parse(value).root))
+        return 'unstable';
+    return undefined;
+}
+export class PathArgumentError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PathArgumentError';
+    }
+}
+let platformOverride;
+export function setPathPlatformForTests(platform) {
+    platformOverride = platform;
+}
+export function requireLocalPath(field, value, opts = {}) {
+    const platform = opts.platform ?? platformOverride ?? process.platform;
+    const path = typeof value === 'string' && HOME_RELATIVE_RE.test(value)
+        ? (platform === 'win32' ? pathWin32 : pathPosix).join(opts.home ?? homedir(), value.slice(2))
+        : value;
+    switch (localPathProblem(path, platform)) {
+        case undefined:
+            return refuseExtendScriptAmbiguity(field, path, platform);
+        case 'not_string':
+            throw new PathArgumentError(`"${field}" is required and must be a non-empty string.`);
+        case 'unc_or_device':
+            throw new PathArgumentError(`"${field}" must be a file on this computer's own drives: network shares (\\\\server\\share), ` +
+                `WebDAV addresses and \\\\?\\ or \\\\.\\ device paths are refused, got "${String(value)}". ` +
+                'Copy the file to a local folder first.');
+        case 'relative':
+            throw new PathArgumentError(`"${field}" must be an absolute path, got "${String(value)}". Pass a full path, e.g. ` +
+                `${platform === 'win32' ? 'C:/Users/you/Pictures/photo.jpg' : '/Users/you/Pictures/photo.jpg'}.`);
+        case 'no_drive':
+            throw new PathArgumentError(`"${field}" must start with a drive letter, got "${String(value)}". Pass e.g. C:/Users/you/Pictures/photo.jpg.`);
+        case 'unstable':
+            throw new PathArgumentError(`"${field}" does not resolve to a stable absolute path ("${String(value)}"). Pass a plain, full path.`);
+    }
+}
+const PERCENT_ESCAPE_RE = /%[0-9A-Fa-f]{2}/;
+const WIN32_DEVICE_NAME_RE = /^(con|prn|aux|nul|conin\$|conout\$|com[0-9¹²³]|lpt[0-9¹²³])\s*(\..*)?$/i;
+function refuseExtendScriptAmbiguity(field, path, platform) {
+    if (PERCENT_ESCAPE_RE.test(path)) {
+        throw new PathArgumentError(`"${field}" must not contain a percent-escape such as %20 or %5F, got "${path}". Write the characters themselves.`);
+    }
+    if (platform === 'win32') {
+        if (path.indexOf(':', 2) !== -1) {
+            throw new PathArgumentError(`"${field}" must not contain ":" after the drive letter, got "${path}".`);
+        }
+        if (WIN32_DEVICE_NAME_RE.test(pathWin32.basename(path))) {
+            throw new PathArgumentError(`"${field}" names a Windows device (${pathWin32.basename(path)}), not a file.`);
+        }
+    }
+    return path;
+}
+export function looksLikePath(value) {
+    return /[\\/]/.test(value) || /^[A-Za-z]:/.test(value) || HOME_RELATIVE_RE.test(value);
+}
+const written = new Set();
+function outputKey(path, platform) {
+    const resolved = (platform === 'win32' ? pathWin32 : pathPosix).resolve(path);
+    return platform === 'win32' || platform === 'darwin' ? resolved.toLowerCase() : resolved;
+}
+export function checkOutputPath(field, value, opts) {
+    const platform = opts.platform ?? platformOverride ?? process.platform;
+    const path = requireLocalPath(field, value, opts);
+    const lower = path.toLowerCase();
+    if (!opts.extensions.some((ext) => lower.endsWith(ext))) {
+        throw new PathArgumentError(`"${field}" must end in ${opts.extensions.join(' or ')}, got "${path}".`);
+    }
+    const exists = opts.exists ?? existsSync;
+    if (opts.overwrite !== true && exists(path) && !written.has(outputKey(path, platform))) {
+        throw new PathArgumentError(`"${field}": a file already exists at "${path}" and was not written in this session. Choose a new ` +
+            'name, or pass overwrite: true only if the user asked to replace that file.');
+    }
+    return path;
+}
+export function recordOutputPath(path, platform = platformOverride ?? process.platform) {
+    written.add(outputKey(path, platform));
+}
+export function resetOutputPathsForTests() {
+    written.clear();
+}

package/dist/utils/operation-timeouts.js

@@ -86,7 +86,6 @@ export const TOOL_TIMEOUT_BUDGETS_MS = {
     gimp_crop_document: 20_000,
     gimp_resize_image: 45_000,
     gimp_transform_canvas: 60_000,
-    gimp_create_mask: 20_000,
     gimp_get_preview: 30_000,
     gimp_get_histogram: 90_000,
     gimp_compare: 45_000,
@@ -97,6 +96,13 @@ export const TOOL_TIMEOUT_BUDGETS_MS = {
     gimp_place_image: 30_000,
     gimp_canvas: 30_000,
     gimp_convert_image_mode: 30_000,
+    gimp_text: 30_000,
+    gimp_select: 20_000,
+    gimp_modify_selection: 90_000,
+    gimp_layer_mask: 15_000,
+    gimp_get_selection_preview: 30_000,
+    gimp_transform_layer: 30_000,
+    gimp_match_layer: 70_000,
 };
 export const TOOLS_WITHOUT_A_BUDGET = {
     ps_report_problem: 'n=3 measured calls',

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '1.7.1';
+export const VERSION = '1.8.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "editmamei",
-  "version": "1.7.1",
+  "version": "1.8.0",
   "description": "Photoshop MCP server: natural-language AI photo editing in desktop Photoshop (Community Edition)",
   "mcpName": "io.github.editmamei/editmamei",
   "editmamei": {
@@ -68,7 +68,7 @@
     "node": ">=22.0.0"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.30.1",
+    "@modelcontextprotocol/sdk": "^1.32.1",
     "adm-zip": "^0.6.1",
     "jpeg-js": "^0.4.4",
     "onnxruntime-web": "1.30.0"