editmamei 1.7.1 → 1.9.0

package/dist/cli/config.js

@@ -50,6 +50,13 @@ const KEYS = {
         },
         coerce: coerceBool,
     },
+    'automation.allow_execute_script': {
+        get: (s) => s.automation.allow_execute_script,
+        set: (s, v) => {
+            s.automation.allow_execute_script = v;
+        },
+        coerce: coerceBool,
+    },
     ps_path: {
         get: (s) => s.ps_path,
         set: (s, v) => {

package/dist/core/server.js

@@ -66,6 +66,14 @@ export const FIRST_RUN_DISCLOSURE = 'First run: Editmamei collects content-free
     '`editmamei config set telemetry.usage false` (or edit ~/.editmamei/settings.json). ' +
     'Opt in to sanitized diagnostics: `editmamei config set telemetry.diagnostics true`.';
 export const BACKGROUND_VERSION_PROBE_TIMEOUT_MS = 3_000;
+const PING_ROUND_TRIP_CLASSES = new Set([
+    'timeout',
+    'ps_modal_blocking',
+    'ps_not_running',
+    'ps_general_error',
+    'file_io',
+]);
+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;
     logger;
@@ -83,6 +91,7 @@ export class EditmameiServer {
     }
     psVersion = null;
     lastPingReachedPs = null;
+    lastPingFailure = null;
     lastTelemetryCallKeyHash = null;
     lastPsLocale = null;
     lastDocDepth = null;
@@ -169,8 +178,13 @@ export class EditmameiServer {
                 });
                 const telemetrySuccess = entry.tool === 'ps_ping' && this.lastPingReachedPs === false ? false : entry.success;
                 const isPingDowngrade = entry.tool === 'ps_ping' && !telemetrySuccess && entry.error === undefined;
+                const pingFailure = isPingDowngrade ? this.lastPingFailure : null;
                 const errorClass = classifyError(entry.error) ??
-                    (telemetrySuccess ? null : isPingDowngrade ? 'ps_not_running' : NO_ERROR_TEXT_CLASS);
+                    (telemetrySuccess
+                        ? null
+                        : isPingDowngrade
+                            ? (pingFailure?.errorClass ?? 'ps_not_running')
+                            : NO_ERROR_TEXT_CLASS);
                 const telemetryCallKeyHash = hashRetryKey(entry.tool, entry.args);
                 const isTelemetryRetry = telemetryCallKeyHash !== null && telemetryCallKeyHash === this.lastTelemetryCallKeyHash;
                 if (telemetryCallKeyHash !== null)
@@ -189,7 +203,7 @@ export class EditmameiServer {
                         error_class: errorClass ?? NO_ERROR_TEXT_CLASS,
                         error_message: entry.error ||
                             (isPingDowngrade
-                                ? 'ps_ping did not reach Photoshop'
+                                ? (pingFailure?.message ?? 'ps_ping did not reach Photoshop')
                                 : 'tool reported failure with no message'),
                         ...(this.lastPsLocale !== null ? { ps_locale: this.lastPsLocale } : {}),
                         ...(this.lastDocDepth !== null ? { doc_depth: this.lastDocDepth } : {}),
@@ -493,8 +507,15 @@ export class EditmameiServer {
             }
         })();
     }
+    markPingUnreachable(errorClass, message) {
+        this.lastPingReachedPs = false;
+        this.lastPingFailure = { errorClass, message };
+        this.lastDocDepth = null;
+        this.lastDocMode = null;
+    }
     async pingPhotoshop() {
         this.lastPingReachedPs = null;
+        this.lastPingFailure = null;
         this.refreshLicenseOnPing();
         if (this.updateCheck)
             await this.updateCheck;
@@ -515,17 +536,41 @@ export class EditmameiServer {
         const degraded = [];
         let versionIsLive = false;
         let pingStateObserved = false;
+        let detectError = null;
         try {
             const detected = await connection.getVersion();
             if (detected)
                 version = detected;
         }
-        catch {
+        catch (err) {
+            detectError = err instanceof Error ? err.message : String(err);
+        }
+        if (connection.getPhotoshopInfo() === null && unsupportedHostReason() === null) {
+            this.markPingUnreachable('ps_not_detected', detectError ?? 'No Photoshop install was detected');
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: withAdvisory('Editmamei could not find a Photoshop install on this computer. Photoshop must be ' +
+                            'installed on the same computer as Editmamei. ' +
+                            (process.env.PHOTOSHOP_PATH?.trim()
+                                ? 'PHOTOSHOP_PATH is set, but does not point at a Photoshop install: check it '
+                                : 'If it is installed in a custom location, set PHOTOSHOP_PATH to its full path ') +
+                            "in your MCP client's Editmamei config (see " +
+                            PHOTOSHOP_PATH_DOCS_URL +
+                            '), restart the client, then call ps_ping again.' +
+                            update.note),
+                    },
+                ],
+                structuredContent: {
+                    connected: false,
+                    update_available: this.updateInfo,
+                    notify_user: update.notify,
+                },
+            };
         }
         if (connection.getPhotoshopInfo() !== null && !(await connection.isCurrentlyRunning())) {
-            this.lastPingReachedPs = false;
-            this.lastDocDepth = null;
-            this.lastDocMode = null;
+            this.markPingUnreachable('ps_not_running', 'Photoshop is installed but no Photoshop process is running');
             return {
                 content: [
                     {
@@ -550,9 +595,7 @@ export class EditmameiServer {
             const alive = await connection.ping().catch(() => false);
             if (!alive) {
                 const reason = unsupportedHostReason();
-                this.lastPingReachedPs = false;
-                this.lastDocDepth = null;
-                this.lastDocMode = null;
+                this.markPingUnreachable('ps_not_running', reason ?? 'pingState snippet build failed and the fallback ping did not reach Photoshop');
                 return {
                     content: [
                         {
@@ -575,10 +618,12 @@ export class EditmameiServer {
                 state = (await runScript(connection, pingStateSnippet));
             }
             catch (err) {
-                this.logger.warn(`pingState snippet failed: ${err instanceof Error ? err.message : String(err)}`);
-                this.lastPingReachedPs = false;
-                this.lastDocDepth = null;
-                this.lastDocMode = null;
+                const message = err instanceof Error ? err.message : String(err);
+                this.logger.warn(`pingState snippet failed: ${message}`);
+                const errorClass = classifyError(message);
+                this.markPingUnreachable(errorClass !== null && PING_ROUND_TRIP_CLASSES.has(errorClass)
+                    ? errorClass
+                    : 'ps_not_running', message);
                 return {
                     content: [
                         {

package/dist/core/settings.js

@@ -21,6 +21,7 @@ function defaults(installId) {
     return {
         telemetry: { usage: true, diagnostics: false, install_id: installId },
         privacy: { send_previews_to_llm: true },
+        automation: { allow_execute_script: true },
         ps_path: null,
         update_check: true,
         editor: 'auto',
@@ -34,6 +35,7 @@ function coerce(raw, installId) {
     const r = raw;
     const t = (r.telemetry ?? {});
     const p = (r.privacy ?? {});
+    const a = (r.automation ?? {});
     return {
         telemetry: {
             usage: typeof t.usage === 'boolean' ? t.usage : base.telemetry.usage,
@@ -47,6 +49,11 @@ function coerce(raw, installId) {
                 ? p.send_previews_to_llm
                 : base.privacy.send_previews_to_llm,
         },
+        automation: {
+            allow_execute_script: typeof a.allow_execute_script === 'boolean'
+                ? a.allow_execute_script
+                : base.automation.allow_execute_script,
+        },
         ps_path: typeof r.ps_path === 'string' ? r.ps_path : null,
         update_check: typeof r.update_check === 'boolean' ? r.update_check : base.update_check,
         editor: typeof r.editor === 'string' && EDITOR_PINS.includes(r.editor)

package/dist/core/tool-activity.js

@@ -1,3 +1,9 @@
+export const RECIPE_TOOLS = new Set([
+    'ps_template_apply',
+    'ps_batch',
+    'ps_sequence',
+    'ps_play_action',
+]);
 export const READ_ONLY_TOOLS = new Set([
     'ps_sequence',
     'ps_batch',
@@ -29,6 +35,7 @@ export const READ_ONLY_TOOLS = new Set([
     'gimp_get_preview',
     'gimp_get_histogram',
     'gimp_compare',
+    'gimp_get_selection_preview',
 ]);
 export const KEPT_WORK_TOOLS = new Set([
     'ps_export',
@@ -109,14 +116,21 @@ export const MUTATING_TOOLS = new Set([
     'gimp_crop_document',
     'gimp_resize_image',
     'gimp_transform_canvas',
-    'gimp_create_mask',
     'gimp_checkpoint',
     'gimp_layer',
     'gimp_bake',
     'gimp_create_document',
     'gimp_place_image',
     'gimp_canvas',
+    'gimp_text',
     'gimp_convert_image_mode',
+    'gimp_select',
+    'gimp_modify_selection',
+    'gimp_layer_mask',
+    'gimp_transform_layer',
+    'gimp_match_layer',
+    'gimp_retouch',
+    'gimp_fill',
 ]);
 export const RAW_DEVELOP_TOOL = 'ps_develop_raw';
 export const CAMERA_RAW_TOOL = 'ps_apply_camera_raw';

package/dist/core/tool-groups.js

@@ -187,14 +187,22 @@ export const TOOL_GROUPS = {
     gimp_add_adjustment: 'adjust',
     gimp_filter: 'filter',
     gimp_add_effect: 'filter',
-    gimp_create_mask: 'masks',
     gimp_checkpoint: 'document',
     gimp_layer: 'layers',
     gimp_bake: 'layers',
+    gimp_transform_layer: 'layers',
     gimp_create_document: 'document',
     gimp_place_image: 'layers',
     gimp_canvas: 'document',
+    gimp_text: 'layers',
     gimp_convert_image_mode: 'document',
+    gimp_select: 'select',
+    gimp_modify_selection: 'select',
+    gimp_layer_mask: 'masks',
+    gimp_get_selection_preview: 'verify',
+    gimp_match_layer: 'layers',
+    gimp_retouch: 'layers',
+    gimp_fill: 'layers',
 };
 export function groupOf(toolName) {
     const group = TOOL_GROUPS[toolName];

package/dist/core/tool-tiers.js

@@ -102,17 +102,25 @@ export const TOOL_TIERS = {
     gimp_crop_document: 'community',
     gimp_resize_image: 'community',
     gimp_transform_canvas: 'community',
-    gimp_create_mask: 'community',
     gimp_get_preview: 'community',
     gimp_get_histogram: 'community',
     gimp_compare: 'community',
     gimp_checkpoint: 'community',
     gimp_layer: 'community',
     gimp_bake: 'community',
+    gimp_transform_layer: 'community',
     gimp_create_document: 'community',
     gimp_place_image: 'community',
     gimp_canvas: 'community',
+    gimp_text: 'community',
     gimp_convert_image_mode: 'community',
+    gimp_select: 'community',
+    gimp_modify_selection: 'community',
+    gimp_layer_mask: 'community',
+    gimp_get_selection_preview: 'community',
+    gimp_match_layer: 'dev',
+    gimp_retouch: 'dev',
+    gimp_fill: 'dev',
 };
 export function tierOf(toolName) {
     const tier = TOOL_TIERS[toolName];

package/dist/delivery/client.js

@@ -157,6 +157,9 @@ export class DeliveryClient {
         if (status === 404) {
             return new DeliveryError('Requested module/version was not found.', 404, 'not_found');
         }
+        if (status === 451) {
+            return new DeliveryError("Editmamei Pro downloads aren't available in your region.", 451, 'unavailable_in_region');
+        }
         return new DeliveryError(`Delivery request failed (HTTP ${status}).`, status, 'server', retryAfterMs);
     }
 }

package/dist/modules/gimp/index.js

@@ -8,11 +8,16 @@ import { createGimpAdjustmentTools } from '../../tools/gimp-adjustment-tools.js'
 import { createGimpEffectTools } from '../../tools/gimp-effect-tools.js';
 import { createGimpFilterTools } from '../../tools/gimp-filter-tools.js';
 import { createGimpGeometryTools } from '../../tools/gimp-geometry-tools.js';
-import { createGimpMaskTools } from '../../tools/gimp-mask-tools.js';
 import { createGimpVerifyTools } from '../../tools/gimp-verify-tools.js';
 import { createGimpCheckpointTools } from '../../tools/gimp-checkpoint-tools.js';
 import { createGimpLayerTools } from '../../tools/gimp-layer-tools.js';
+import { createGimpTransformLayerTools } from '../../tools/gimp-transform-layer-tools.js';
 import { createGimpComposeTools } from '../../tools/gimp-compose-tools.js';
+import { createGimpTextTools } from '../../tools/gimp-text-tools.js';
+import { createGimpSelectionTools } from '../../tools/gimp-selection-tools.js';
+import { createGimpMatchTools } from '../../tools/gimp-match-tools.js';
+import { createGimpRetouchTools } from '../../tools/gimp-retouch-tools.js';
+import { createGimpFillTools } from '../../tools/gimp-fill-tools.js';
 export const gimpFactories = [
     createGimpCoreTools,
     createGimpDocumentTools,
@@ -21,11 +26,16 @@ export const gimpFactories = [
     createGimpEffectTools,
     createGimpFilterTools,
     createGimpGeometryTools,
-    createGimpMaskTools,
     createGimpVerifyTools,
     createGimpCheckpointTools,
     createGimpLayerTools,
+    createGimpTransformLayerTools,
     createGimpComposeTools,
+    createGimpTextTools,
+    createGimpSelectionTools,
+    createGimpMatchTools,
+    createGimpRetouchTools,
+    createGimpFillTools,
 ];
 export const gimpModule = {
     manifest: { id: 'gimp', name: 'Editmamei GIMP Tools', abi: KERNEL_ABI },

package/dist/telemetry/sanitize.js

@@ -23,8 +23,22 @@ function homedirPrefixes() {
     return [...set];
 }
 const SINGLE_SEG_POSIX = /(^|\s)\/[^\s"'/]+(?=$|\s)/;
+const WORD = String.raw `[^\s"'\\/:]+`;
+const DIR = String.raw `${WORD}(?: ${WORD})*`;
+const TILDE_WORD = String.raw `[^\s"'\\/]+`;
+const TILDE_DIR = String.raw `${TILDE_WORD}(?: ${TILDE_WORD})*`;
+const POSIX_WORD = String.raw `[^\s"'/]+`;
+const POSIX_DIR = String.raw `${POSIX_WORD}(?: ${POSIX_WORD})*`;
+const PATH_TOKEN = new RegExp([
+    String.raw `[A-Za-z]:[\\/](?:${DIR}[\\/])*[^\s"']*`,
+    String.raw `\\\\(?:${DIR}[\\/])*[^\s"']+`,
+    String.raw `file:\/\/[^\s"']*`,
+    String.raw `(?<![\w~])~(?:[\\/]${TILDE_DIR}(?=[\\/]))*[\\/]${TILDE_WORD}[\\/]?`,
+    String.raw `\/${POSIX_WORD}(?:\/${POSIX_DIR}(?=\/))*\/${POSIX_WORD}\/?`,
+    String.raw `(?:^|\s)\/[^\s"'/]+(?=$|\s)`,
+].join('|'), 'gi');
 function basenamePaths(s) {
-    return s.replace(/[A-Za-z]:[\\/][^\s"']*|\\\\[^\s"']+|file:\/\/[^\s"']*|(?:\/[^\s"'/]+){2,}\/?|(?:^|\s)\/[^\s"'/]+(?=$|\s)/gi, (m) => {
+    return s.replace(PATH_TOKEN, (m) => {
         const single = SINGLE_SEG_POSIX.exec(m);
         if (single)
             return `${single[1]}/…`;

package/dist/tools/adjustment-tools.js

@@ -1,6 +1,7 @@
 import { runScript } from '../utils/run-script.js';
 import { validateArgs } from '../utils/validate.js';
 import { toolErrorResult, runSnippetTool, applyToActiveLayerProp } from '../utils/tool-helpers.js';
+import { looksLikePath, requireLocalPath } from '../utils/local-path.js';
 import { getPendingRawDevelop } from '../core/raw-develop-state.js';
 import { CAMERA_RAW_TOOL } from '../core/tool-activity.js';
 const addAdjustmentLayerSchema = {
@@ -802,6 +803,11 @@ const FORWARDED_KEYS = new Set([
     'pos_levels',
     'thr_level',
 ]);
+function lutNameOrPath(value) {
+    return typeof value === 'string' && looksLikePath(value)
+        ? requireLocalPath('cl_lut_name', value)
+        : value;
+}
 async function addAdjustmentLayer(connection, snippetClient, rawArgs) {
     try {
         const args = validateArgs(addAdjustmentLayerSchema, rawArgs);
@@ -816,6 +822,8 @@ async function addAdjustmentLayer(connection, snippetClient, rawArgs) {
             if (args[key] !== undefined)
                 params[key] = args[key];
         }
+        if (typeof params.cl_lut_name === 'string')
+            params.cl_lut_name = lutNameOrPath(params.cl_lut_name);
         if (type === 'color_lookup' && !params.cl_lut_name) {
             return {
                 content: [
@@ -875,7 +883,7 @@ async function applyColorLookup(connection, snippetClient, rawArgs) {
         snippet: 'applyColorLookup',
         errorPrefix: 'Error applying color lookup',
         params: (args) => ({
-            lutName: args.cl_lut_name,
+            lutName: lutNameOrPath(args.cl_lut_name),
             applyToActiveLayer: args.apply_to_active_layer ?? false,
         }),
         successText: (result) => `Color Lookup applied (BAKE, experimental):\n${JSON.stringify(result, null, 2)}`,

package/dist/tools/document-tools.js

@@ -1,7 +1,9 @@
+import { statSync } from 'node:fs';
 import { runScript } from '../utils/run-script.js';
 import { validateArgs } from '../utils/validate.js';
-import { OPEN_DOCUMENT_TIMEOUT_MS, OPEN_DOCUMENT_REPROBE_TIMEOUT_MS, } from '../utils/operation-timeouts.js';
+import { OPEN_DOCUMENT_TIMEOUT_MS, OPEN_DOCUMENT_REPROBE_TIMEOUT_MS, SAVE_PSD_REPROBE_TIMEOUT_MS, getToolTimeoutMs, } from '../utils/operation-timeouts.js';
 import { toolErrorResult, runSnippetTool } from '../utils/tool-helpers.js';
+import { checkOutputPath, recordOutputPath, requireLocalPath } from '../utils/local-path.js';
 import { purgeSceneChannels } from '../perception/region-precompute.js';
 import { Logger } from '../utils/logger.js';
 const logger = new Logger('document-tools');
@@ -76,7 +78,7 @@ const openDocumentSchema = {
     properties: {
         file_path: {
             type: 'string',
-            description: 'Absolute path to the file to open',
+            description: "Absolute path to the file to open, on this computer's own drives (network shares are refused).",
         },
         suppress_dialogs: {
             type: 'boolean',
@@ -96,7 +98,14 @@ const savePsdSchema = {
     properties: {
         output_path: {
             type: 'string',
-            description: 'Absolute output path including filename, e.g. E:\\Photos\\Edit\\shell_01.psd',
+            description: 'Absolute output path including filename, ending in .psd, e.g. E:\\Photos\\Edit\\shell_01.psd',
+        },
+        overwrite: {
+            type: 'boolean',
+            description: 'Replace an existing file at output_path that this session did not write. Default false: such a ' +
+                'save is refused, so an original is never replaced by accident. Set true only when the user asked ' +
+                'to replace that file. A file this session already wrote can be saved over without it.',
+            default: false,
         },
         maximize_compatibility: {
             type: 'boolean',
@@ -116,7 +125,14 @@ const exportJpegSchema = {
     properties: {
         output_path: {
             type: 'string',
-            description: 'Absolute output path including filename.',
+            description: 'Absolute output path including filename, ending in .jpg.',
+        },
+        overwrite: {
+            type: 'boolean',
+            description: 'Replace an existing file at output_path that this session did not write. Default false: such a ' +
+                'save is refused, so an original is never replaced by accident. Set true only when the user asked ' +
+                'to replace that file. A file this session already wrote can be saved over without it.',
+            default: false,
         },
         quality: {
             type: 'integer',
@@ -149,7 +165,14 @@ const exportPngSchema = {
     properties: {
         output_path: {
             type: 'string',
-            description: 'Absolute output path including filename.',
+            description: 'Absolute output path including filename, ending in .png.',
+        },
+        overwrite: {
+            type: 'boolean',
+            description: 'Replace an existing file at output_path that this session did not write. Default false: such a ' +
+                'save is refused, so an original is never replaced by accident. Set true only when the user asked ' +
+                'to replace that file. A file this session already wrote can be saved over without it.',
+            default: false,
         },
         transparent_background: {
             type: 'boolean',
@@ -327,6 +350,15 @@ export function createDocumentTools(connection, snippetClient) {
                         saved_to: { type: 'string' },
                         document_name: { type: 'string' },
                         layers: { type: 'number' },
+                        reprobed: {
+                            type: 'boolean',
+                            description: 'Present when the save outran its time budget and a follow-up check confirmed the file was written. document_name, layers and context are absent then.',
+                        },
+                        bytes: {
+                            type: 'number',
+                            description: 'Size of the written file. Present only with reprobed.',
+                        },
+                        scene_channels_purged: { type: 'number' },
                         context: { type: 'object' },
                     },
                     required: ['success'],
@@ -531,7 +563,7 @@ async function openDocumentPipeline(connection, snippetClient, rawArgs) {
     let filePath;
     try {
         const args = validateArgs(openDocumentSchema, rawArgs);
-        filePath = args.file_path;
+        filePath = requireLocalPath('file_path', args.file_path);
         const suppressDialogs = args.suppress_dialogs;
         const bitDepth = args.bit_depth;
         const script = await snippetClient.build('openDocumentPipeline', {
@@ -579,10 +611,49 @@ async function openDocumentPipeline(connection, snippetClient, rawArgs) {
         return toolErrorResult('Error opening document', error);
     }
 }
+async function reprobeSavedPsd(connection, outputPath, startedAt) {
+    try {
+        await runScript(connection, 'return { ready: true };', SAVE_PSD_REPROBE_TIMEOUT_MS);
+    }
+    catch {
+        return null;
+    }
+    let size;
+    let modifiedMs;
+    try {
+        const stats = statSync(outputPath);
+        if (!stats.isFile())
+            return null;
+        size = stats.size;
+        modifiedMs = stats.mtimeMs;
+    }
+    catch {
+        return null;
+    }
+    if (size === 0 || modifiedMs < startedAt - 2_000)
+        return null;
+    const payload = { success: true, saved_to: outputPath, bytes: size, reprobed: true };
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `PSD saved (the save ran past the ${getToolTimeoutMs('ps_save_psd')}ms budget and was reported as a ` +
+                    `timeout, but a post-timeout check confirmed the file was written):\n` +
+                    JSON.stringify(payload, null, 2),
+            },
+        ],
+        structuredContent: payload,
+    };
+}
 async function savePsdPipeline(connection, snippetClient, rawArgs) {
     let args;
+    let outputPath;
     try {
         args = validateArgs(savePsdSchema, rawArgs);
+        outputPath = checkOutputPath('output_path', args.output_path, {
+            extensions: ['.psd'],
+            overwrite: args.overwrite === true,
+        });
     }
     catch (error) {
         return toolErrorResult('Error saving PSD', error);
@@ -597,19 +668,33 @@ async function savePsdPipeline(connection, snippetClient, rawArgs) {
                 `${err instanceof Error ? err.message : String(err)}`);
         }
     }
-    const res = await runSnippetTool({
-        connection,
-        snippetClient,
-        rawArgs,
-        schema: savePsdSchema,
-        snippet: 'savePsdAsCopy',
-        errorPrefix: 'Error saving PSD',
-        params: (args) => ({
-            outputPath: args.output_path,
+    const startedAt = Date.now();
+    let res;
+    try {
+        const script = await snippetClient.build('savePsdAsCopy', {
+            outputPath,
             maximizeCompat: args.maximize_compatibility,
-        }),
-        successText: (result) => `PSD saved:\n${JSON.stringify(result, null, 2)}`,
-    });
+        });
+        const result = await runScript(connection, script, getToolTimeoutMs('ps_save_psd'));
+        res = {
+            content: [{ type: 'text', text: `PSD saved:\n${JSON.stringify(result, null, 2)}` }],
+            structuredContent: result,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (isScriptTimeoutError(message)) {
+            res =
+                (await reprobeSavedPsd(connection, outputPath, startedAt)) ??
+                    toolErrorResult('Error saving PSD', new Error(`${message} Photoshop may still be writing the file: check whether ${outputPath} ` +
+                        'was just modified before saving again.'));
+        }
+        else {
+            res = toolErrorResult('Error saving PSD', error);
+        }
+    }
+    if (!res.isError)
+        recordOutputPath(outputPath);
     if (!res.isError && typeof res.structuredContent === 'object' && res.structuredContent !== null) {
         res.structuredContent.scene_channels_purged = purged;
     }
@@ -618,7 +703,10 @@ async function savePsdPipeline(connection, snippetClient, rawArgs) {
 async function exportJpegPipeline(connection, snippetClient, rawArgs) {
     try {
         const args = validateArgs(exportJpegSchema, rawArgs);
-        const outputPath = args.output_path;
+        const outputPath = checkOutputPath('output_path', args.output_path, {
+            extensions: ['.jpg'],
+            overwrite: args.overwrite === true,
+        });
         const qualityPct = args.quality;
         const quality = Math.round((qualityPct / 100) * 12);
         const longEdgePx = args.long_edge_px;
@@ -630,6 +718,7 @@ async function exportJpegPipeline(connection, snippetClient, rawArgs) {
         const script = await snippetClient.build('exportJpegPipeline', params);
         const result = (await runScript(connection, script));
         const structured = { ...result, quality: qualityPct, quality_ps_scale: quality };
+        recordOutputPath(outputPath);
         return {
             content: [
                 {
@@ -645,7 +734,8 @@ async function exportJpegPipeline(connection, snippetClient, rawArgs) {
     }
 }
 async function exportPngPipeline(connection, snippetClient, rawArgs) {
-    return runSnippetTool({
+    let outputPath;
+    const res = await runSnippetTool({
         connection,
         snippetClient,
         rawArgs,
@@ -654,8 +744,12 @@ async function exportPngPipeline(connection, snippetClient, rawArgs) {
         errorPrefix: 'Error exporting PNG',
         params: (args) => {
             const longEdgePx = args.long_edge_px;
+            outputPath = checkOutputPath('output_path', args.output_path, {
+                extensions: ['.png'],
+                overwrite: args.overwrite === true,
+            });
             const params = {
-                outputPath: args.output_path,
+                outputPath,
                 transparentBg: args.transparent_background,
                 compression: args.compression,
             };
@@ -665,4 +759,7 @@ async function exportPngPipeline(connection, snippetClient, rawArgs) {
         },
         successText: (result) => `PNG exported:\n${JSON.stringify(result, null, 2)}`,
     });
+    if (!res.isError && outputPath !== undefined)
+        recordOutputPath(outputPath);
+    return res;
 }

package/dist/tools/filter-tools.js

@@ -3,6 +3,7 @@ import { validateArgs } from '../utils/validate.js';
 import { OnnxLandmarkDetectionClient } from '../detection/landmark-detection-client.js';
 import { resolveGatedPlacement, PLACEMENT_SCHEMA } from '../perception/grounding-locate.js';
 import { toolErrorResult, runSnippetTool, applyToActiveLayerProp, asSmartFilterProp, unknownDiscriminator, } from '../utils/tool-helpers.js';
+import { requireLocalPath } from '../utils/local-path.js';
 import { LAYER_BLEND_MODES } from '../utils/blend-modes.js';
 import { runSmartFilterOp } from './smart-object-tools.js';
 const gaussianBlurSchema = {
@@ -1652,7 +1653,7 @@ async function applyDisplace(connection, snippetClient, rawArgs) {
         snippet: 'applyDisplace',
         errorPrefix: 'Error applying Displace',
         params: (args) => ({
-            mapPath: args.map_path,
+            mapPath: requireLocalPath('map_path', args.map_path),
             horizontalScale: args.horizontal_scale ?? 10,
             verticalScale: args.vertical_scale ?? 10,
             displacementMap: args.displacement_map ?? 'stretch_to_fit',