editmamei 1.1.0 → 1.2.1

package/dist/tools/sky-tools.js

@@ -0,0 +1,126 @@
+import { runSnippetTool } from '../utils/tool-helpers.js';
+import { SKY_REPLACEMENT_TIMEOUT_MS } from '../utils/operation-timeouts.js';
+const PLACEHOLDER_SKY_ID = '00000000-0000-0000-0000-000000000000';
+const replaceSkyInputSchema = {
+    type: 'object',
+    properties: {
+        sky_file: {
+            type: 'string',
+            description: 'ABSOLUTE path to the image to use as the sky. Any image Photoshop can open works — it does not need to be a registered Photoshop sky preset. The built-in skies live as .jpg files under the Sky_Presets folder inside your Photoshop settings directory, and their paths can be passed here directly.',
+        },
+        sky_name: {
+            type: 'string',
+            description: 'Label recorded on the operation. Cosmetic — it does not select the sky, sky_file does.',
+            default: 'Custom Sky',
+        },
+        shift_edge: {
+            type: 'number',
+            description: 'Moves the sky/foreground boundary inward (negative) or outward (positive). Use it when the horizon leaves a halo or eats into the foreground.',
+            default: 0,
+            minimum: -100,
+            maximum: 100,
+        },
+        border_smoothness: {
+            type: 'number',
+            description: 'Softens the boundary between sky and foreground. 0 is a hard cut.',
+            default: 50,
+            minimum: 0,
+            maximum: 100,
+        },
+        brightness: {
+            type: 'number',
+            description: 'Brightness of the replaced sky itself.',
+            default: 0,
+            minimum: -100,
+            maximum: 100,
+        },
+        temperature: {
+            type: 'number',
+            description: 'Warms (positive) or cools (negative) the replaced sky.',
+            default: 0,
+            minimum: -100,
+            maximum: 100,
+        },
+        harmonization_opacity: {
+            type: 'number',
+            description: 'How strongly the foreground is colour-graded to match the new sky. This is what sells the composite — 0 leaves the foreground untouched and usually reads as pasted-on.',
+            default: 35,
+            minimum: 0,
+            maximum: 100,
+        },
+        foreground_lighting_opacity: {
+            type: 'number',
+            description: 'Strength of the relighting applied to the foreground so it appears lit by the new sky.',
+            default: 78,
+            minimum: 0,
+            maximum: 100,
+        },
+        edge_lighting_opacity: {
+            type: 'number',
+            description: 'Strength of the light wrap along the foreground edge where it meets the sky.',
+            default: 70,
+            minimum: 0,
+            maximum: 100,
+        },
+    },
+    required: ['sky_file'],
+};
+async function replaceSky(connection, snippetClient, rawArgs) {
+    return runSnippetTool({
+        connection,
+        snippetClient,
+        rawArgs,
+        schema: replaceSkyInputSchema,
+        snippet: 'replaceSky',
+        errorPrefix: 'Error running Sky Replacement',
+        timeoutMs: SKY_REPLACEMENT_TIMEOUT_MS,
+        params: (args) => ({
+            skyPath: args.sky_file,
+            skyName: args.sky_name ?? 'Custom Sky',
+            skyId: PLACEHOLDER_SKY_ID,
+            shiftEdge: args.shift_edge ?? 0,
+            borderSmoothness: args.border_smoothness ?? 50,
+            brightness: args.brightness ?? 0,
+            temperature: args.temperature ?? 0,
+            harmonizationOpacity: args.harmonization_opacity ?? 35,
+            foregroundLightingOpacity: args.foreground_lighting_opacity ?? 78,
+            edgeLightingOpacity: args.edge_lighting_opacity ?? 70,
+        }),
+        successText: (_result, args) => `Sky replaced using ${String(args.sky_file)}`,
+    });
+}
+export function createSkyTools(connection, snippetClient) {
+    return [
+        {
+            tool: {
+                name: 'ps_replace_sky',
+                description: 'Run Photoshop\'s Sky Replacement (Adobe Sensei): detect the sky, composite a replacement, and relight/colour-grade the foreground to match. Non-destructive — everything lands in a "Sky Replacement Group" of editable layers above the original, so the result can be tuned or deleted afterwards. sky_file takes an ABSOLUTE path to ANY image on disk, not only Photoshop\'s built-in presets. Reach for harmonization_opacity and foreground_lighting_opacity when the composite reads as pasted-on; those two carry most of the believability. Fails cleanly when the image has no detectable sky (indoor or closed compositions).',
+                inputSchema: replaceSkyInputSchema,
+                outputSchema: {
+                    type: 'object',
+                    properties: {
+                        replaced: { type: 'boolean' },
+                        strategy_used: { type: 'string' },
+                        group_name: {
+                            type: 'string',
+                            description: 'Name of the layer group Photoshop created.',
+                        },
+                        group_layers: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Layers inside the group, top to bottom — typically the sky layer, an edge-lighting group, a foreground-lighting layer and a foreground-colour curves layer.',
+                        },
+                        sky_file: { type: 'string' },
+                        sky_name: { type: 'string' },
+                        context: { type: 'object' },
+                    },
+                },
+                annotations: {
+                    title: 'Replace Sky (Sensei)',
+                    idempotentHint: false,
+                },
+            },
+            handler: async (args) => replaceSky(connection, snippetClient, args),
+        },
+    ];
+}

package/dist/tools/text-tools.js

@@ -70,24 +70,6 @@ const updateTextContentSchema = {
     },
     required: ['text'],
 };
-const SET_TEXT_PROPERTIES = ['font', 'color', 'alignment', 'content'];
-const SET_TEXT_INPUT_SCHEMA = {
-    type: 'object',
-    properties: {
-        property: {
-            type: 'string',
-            enum: [...SET_TEXT_PROPERTIES],
-            description: 'Which text attribute to set on the active text layer: ' +
-                'font(font_name, optional font_size); color(red, green, blue); ' +
-                'alignment(alignment); content(text).',
-        },
-        ...setTextFontSchema.properties,
-        ...setTextColorSchema.properties,
-        ...setTextAlignmentSchema.properties,
-        ...updateTextContentSchema.properties,
-    },
-    required: ['property'],
-};
 const TEXT_OPS = ['create', 'set_content', 'set_font', 'set_color', 'set_alignment'];
 export const TEXT_OP_SCHEMAS = {
     create: createTextLayerSchema,
@@ -161,33 +143,6 @@ export function createTextTools(connection, snippetClient) {
             },
             handler: async (args) => textDispatch(connection, snippetClient, args),
         },
-        {
-            tool: {
-                name: 'ps_set_text',
-                description: 'DEPRECATED — use ps_text(op=set_font / set_color / set_alignment / set_content) instead (kept for one release for backward compatibility, identical behaviour). Set an attribute of the currently active text layer — font (family or PostScript name, optionally size), color (RGB), alignment, or text content — selected via `property`. Idempotent. Throws if the active layer is not a text layer. Font names accept either the PostScript name ("ArialMT") or family name ("Arial", resolved to its Regular/first variant); throws clearly if no installed font matches.',
-                inputSchema: SET_TEXT_INPUT_SCHEMA,
-                outputSchema: {
-                    type: 'object',
-                    properties: {
-                        requested: { type: 'string' },
-                        font: { type: 'string' },
-                        size: { type: 'number' },
-                        matched_by: {
-                            type: 'string',
-                            enum: ['postScriptName', 'family+regular', 'family', 'name'],
-                        },
-                        color: { type: 'string' },
-                        alignment: { type: 'string' },
-                        text: { type: 'string' },
-                    },
-                },
-                annotations: {
-                    title: 'Set Text',
-                    idempotentHint: true,
-                },
-            },
-            handler: async (args) => setText(connection, snippetClient, args),
-        },
     ];
 }
 async function textDispatch(connection, snippetClient, rawArgs) {
@@ -208,30 +163,6 @@ async function textDispatch(connection, snippetClient, rawArgs) {
             return unknownDiscriminator('text op', op, TEXT_OPS);
     }
 }
-async function setText(connection, snippetClient, rawArgs) {
-    const property = rawArgs.property;
-    const { property: _omit, ...rest } = rawArgs;
-    switch (property) {
-        case 'font':
-            return setTextFont(connection, snippetClient, rest);
-        case 'color':
-            return setTextColor(connection, snippetClient, rest);
-        case 'alignment':
-            return setTextAlignment(connection, snippetClient, rest);
-        case 'content':
-            return updateTextContent(connection, snippetClient, rest);
-        default:
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Error: unknown text property "${String(property)}". Allowed: ${SET_TEXT_PROPERTIES.join(', ')}.`,
-                    },
-                ],
-                isError: true,
-            };
-    }
-}
 async function setTextFont(connection, snippetClient, rawArgs) {
     return runSnippetTool({
         connection,

package/dist/update/check.js

@@ -1,10 +1,33 @@
 import { VERSION } from '../version.js';
 import { resolveInstallChannel } from '../install-channel.js';
-const DEFAULT_DIST_TAGS_URL = 'https://registry.npmjs.org/-/package/editmamei/dist-tags';
+const DEFAULT_LATEST_MANIFEST_URL = 'https://registry.npmjs.org/editmamei/latest';
 const RELEASES_URL = 'https://editmamei.com/download';
 export function resolveUpdateCheckUrl(env = process.env) {
     const override = env.EDITMAMEI_UPDATE_CHECK_URL;
-    return override && override.length > 0 ? override : DEFAULT_DIST_TAGS_URL;
+    return override && override.length > 0 ? override : DEFAULT_LATEST_MANIFEST_URL;
+}
+const MAX_FIX_VERSIONS = 16;
+const MAX_TOOLS_PER_VERSION = 16;
+const MAX_TOOL_NAME_LENGTH = 64;
+export function parseFixesByVersion(raw) {
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
+        return {};
+    const out = {};
+    let versions = 0;
+    for (const [version, tools] of Object.entries(raw)) {
+        if (versions >= MAX_FIX_VERSIONS)
+            break;
+        if (!parseSemver(version) || !Array.isArray(tools))
+            continue;
+        const names = tools
+            .filter((t) => typeof t === 'string' && t.length > 0 && t.length <= MAX_TOOL_NAME_LENGTH)
+            .slice(0, MAX_TOOLS_PER_VERSION);
+        if (names.length > 0) {
+            out[version] = names;
+            versions++;
+        }
+    }
+    return out;
 }
 export function httpFetchLatest() {
     return async (url, timeoutMs) => {
@@ -18,7 +41,12 @@ export function httpFetchLatest() {
             if (!res.ok)
                 return null;
             const data = (await res.json());
-            return typeof data.latest === 'string' ? data.latest : null;
+            if (typeof data.version !== 'string')
+                return null;
+            return {
+                version: data.version,
+                fixesByVersion: parseFixesByVersion(data.editmamei?.fixesByVersion),
+            };
         }
         catch {
             return null;
@@ -43,6 +71,30 @@ export function isNewer(latest, current) {
     }
     return false;
 }
+export function fixedToolsSince(fixesByVersion, current, latest) {
+    const versions = Object.keys(fixesByVersion)
+        .filter((v) => isNewer(v, current) && !isNewer(v, latest))
+        .sort((a, b) => {
+        const pa = parseSemver(a);
+        const pb = parseSemver(b);
+        for (let i = 0; i < 3; i++) {
+            if (pa[i] !== pb[i])
+                return pa[i] - pb[i];
+        }
+        return 0;
+    });
+    const seen = new Set();
+    const out = [];
+    for (const v of versions) {
+        for (const tool of fixesByVersion[v]) {
+            if (!seen.has(tool)) {
+                seen.add(tool);
+                out.push(tool);
+            }
+        }
+    }
+    return out;
+}
 export function updateMessage(channel, latest) {
     switch (channel) {
         case 'mcpb':
@@ -64,12 +116,19 @@ export async function checkForUpdate(opts = {}) {
         const current = opts.current ?? VERSION;
         const channel = resolveInstallChannel(env);
         const fetchLatest = opts.fetchLatest ?? httpFetchLatest();
-        const latest = await fetchLatest(resolveUpdateCheckUrl(env), opts.timeoutMs ?? 4000);
-        if (!latest || !parseSemver(latest))
+        const manifest = await fetchLatest(resolveUpdateCheckUrl(env), opts.timeoutMs ?? 4000);
+        if (!manifest || !parseSemver(manifest.version))
             return null;
+        const latest = manifest.version;
         if (!isNewer(latest, current))
             return null;
-        return { current, latest, channel, how_to_update: updateMessage(channel, latest) };
+        return {
+            current,
+            latest,
+            channel,
+            how_to_update: updateMessage(channel, latest),
+            fixed_tools: fixedToolsSince(manifest.fixesByVersion, current, latest),
+        };
     }
     catch {
         return null;

package/dist/update/session-fixes.js

@@ -0,0 +1,33 @@
+import { listRecentSessionIds, readSessionLog, } from '../utils/session-log-reader.js';
+const RECENT_SESSION_SCAN_LIMIT = 5;
+export async function previousSessionFailureCounts(currentSessionId, opts = {}) {
+    const ids = await listRecentSessionIds(RECENT_SESSION_SCAN_LIMIT, opts);
+    for (const id of ids) {
+        if (id === currentSessionId)
+            continue;
+        const entries = await readSessionLog(id, opts);
+        const counts = new Map();
+        let sawCall = false;
+        for (const entry of entries) {
+            if ('type' in entry && entry.type === 'meta')
+                continue;
+            const call = entry;
+            if (typeof call.tool !== 'string')
+                continue;
+            sawCall = true;
+            if (call.success === false) {
+                counts.set(call.tool, (counts.get(call.tool) ?? 0) + 1);
+            }
+        }
+        if (sawCall)
+            return counts;
+    }
+    return new Map();
+}
+export function relevantFixes(failureCounts, fixedTools, cap = 3) {
+    return fixedTools
+        .filter((tool) => (failureCounts.get(tool) ?? 0) > 0)
+        .map((tool) => ({ tool, failures: failureCounts.get(tool) }))
+        .sort((a, b) => b.failures - a.failures)
+        .slice(0, cap);
+}

package/dist/utils/jsx.js

@@ -1,5 +1,6 @@
+const NON_ASCII = /[^ -~]/g;
 export function jsLit(value) {
-    return JSON.stringify(String(value));
+    return JSON.stringify(String(value)).replace(NON_ASCII, (ch) => `\\u${ch.charCodeAt(0).toString(16).padStart(4, '0')}`);
 }
 export function jsNum(value, fallback) {
     const n = typeof value === 'number' ? value : Number(value);

package/dist/utils/operation-timeouts.js

@@ -3,5 +3,7 @@ export const OPEN_DOCUMENT_REPROBE_TIMEOUT_MS = 10_000;
 export const CAMERA_RAW_FILTER_TIMEOUT_MS = 120_000;
 export const SELECT_SUBJECT_TIMEOUT_MS = 120_000;
 export const SELECT_SKY_TIMEOUT_MS = 120_000;
+export const SELECT_FOCUS_AREA_TIMEOUT_MS = 120_000;
+export const SKY_REPLACEMENT_TIMEOUT_MS = 120_000;
 export const ANNOTATED_PREVIEW_TIMEOUT_MS = 90_000;
 export const SCENE_CHANNEL_TIMEOUT_MS = 120_000;

package/dist/utils/session-log.js

@@ -24,6 +24,7 @@ export function generateSessionId(now = new Date()) {
 }
 export const ERROR_CLASS_TABLE = [
     { errorClass: 'ps_empty_error', pattern: /returned an empty error|failed with no message/i },
+    { errorClass: 'wrong_layer_kind', pattern: /is a group, not an art layer/i },
     {
         errorClass: 'layer_not_found',
         pattern: /\blayer not found|no layer named|(?:layer_to_move|target_layer_name) not found|layer "[^"]*" not found/i,
@@ -37,6 +38,19 @@ export const ERROR_CLASS_TABLE = [
         pattern: /file not found|map not found|lut not found|could not open lut/i,
     },
     { errorClass: 'face_not_found', pattern: /no face mesh|no face detected/i },
+    {
+        errorClass: 'perception_export_failed',
+        pattern: /saveAs reported success but no file/i,
+    },
+    { errorClass: 'image_decode_failed', pattern: /failed to decode jpeg/i },
+    {
+        errorClass: 'detection_unavailable',
+        pattern: /onnxruntime|onnx runtime/i,
+    },
+    {
+        errorClass: 'file_io',
+        pattern: /\b(ENOENT|EBUSY|EACCES|EPERM|EMFILE|ENOSPC)\b/,
+    },
     {
         errorClass: 'schema_validation',
         pattern: /\bvalidat|required.*field|missing required argument|must be.*type|invalid (input|argument)/i,
@@ -210,6 +224,9 @@ export class SessionLog {
     get path() {
         return join(this.dir, `${this.sessionId}.ndjson`);
     }
+    get directory() {
+        return this.dir;
+    }
     setMcpClientGetter(fn) {
         this.getMcpClientFn = fn;
     }

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '1.1.0';
+export const VERSION = '1.2.1';

package/package.json

@@ -1,8 +1,22 @@
 {
   "name": "editmamei",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "Photoshop MCP server: natural-language AI photo editing with your own Photoshop (Community Edition)",
   "mcpName": "io.github.editmamei/editmamei",
+  "editmamei": {
+    "fixesByVersion": {
+      "1.1.0": [
+        "ps_create_clipping_mask"
+      ],
+      "1.2.0": [
+        "ps_delete_layer",
+        "ps_select_layer"
+      ],
+      "1.2.1": [
+        "ps_read_scene"
+      ]
+    }
+  },
   "main": "dist/index.js",
   "type": "module",
   "bin": {