editmamei 1.0.3 → 1.2.0

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

@@ -23,21 +23,58 @@ export function generateSessionId(now = new Date()) {
     return `${iso}-${suffix}`;
 }
 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,
+    },
+    { errorClass: 'group_not_found', pattern: /group not found/i },
+    { errorClass: 'channel_not_found', pattern: /channel not found|channel named/i },
+    { errorClass: 'path_not_found', pattern: /no path named|no paths to|no work path/i },
+    { errorClass: 'font_not_found', pattern: /font not found/i },
+    {
+        errorClass: 'file_not_found',
+        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: 'schema_validation',
-        pattern: /\bvalidat|required.*field|must be.*type|invalid (input|argument)/i,
+        pattern: /\bvalidat|required.*field|missing required argument|must be.*type|invalid (input|argument)/i,
     },
-    { errorClass: 'layer_not_found', pattern: /layer .* not found|no layer named/i },
-    { errorClass: 'ps_command_unavailable', pattern: /not currently available/i },
-    { errorClass: 'timeout', pattern: /timed? ?out|Script execution timeout|exceeded.*bytes/i },
     {
-        errorClass: 'ps_modal_blocking',
-        pattern: /modal.*dialog|dialog.*blocking|blocked.*modal|photoshop.*modal/i,
+        errorClass: 'invalid_argument',
+        pattern: /unknown [^:]{1,30}:|invalid |illegal argument|must be |out of bounds|unsupported/i,
     },
+    { errorClass: 'ps_not_detected', pattern: /photoshop info not available/i },
     {
         errorClass: 'ps_not_running',
         pattern: /CreateObject|photoshop.*not.*running|cannot connect.*photoshop|connection.*failed/i,
     },
+    { errorClass: 'no_document', pattern: /no active document|no document is open/i },
+    { errorClass: 'no_active_layer', pattern: /no active layer|document has no layers/i },
+    {
+        errorClass: 'no_selection',
+        pattern: /no active selection|requires an active selection|make a selection/i,
+    },
+    { errorClass: 'background_layer', pattern: /background layer/i },
+    { errorClass: 'layer_locked', pattern: /is locked|fully locked|locked layer/i },
+    {
+        errorClass: 'wrong_layer_kind',
+        pattern: /pixel layer|text layer|smart object layer|layer kind|rasterize it first/i,
+    },
+    { errorClass: 'ps_command_unavailable', pattern: /not currently available/i },
+    { errorClass: 'timeout', pattern: /timed? ?out|Script execution timeout|exceeded.*bytes/i },
+    {
+        errorClass: 'ps_modal_blocking',
+        pattern: /modal.*dialog|dialog.*blocking|blocked.*modal|photoshop.*modal/i,
+    },
+    { errorClass: 'ai_selection_no_result', pattern: /returned no result/i },
+    { errorClass: 'ps_general_error', pattern: /general photoshop error/i },
+    { errorClass: 'ps_no_such_element', pattern: /no such element/i },
+    { errorClass: 'write_not_verified', pattern: /did not verify/i },
+    { errorClass: 'ps_empty_error', pattern: /:\s*$/ },
+    { errorClass: 'ps_op_failed', pattern: /failed[: (]/i },
 ];
 export function classifyError(error) {
     if (error === undefined)
@@ -174,6 +211,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/utils/temp.js

@@ -53,7 +53,7 @@ export class TempDir {
             const fbMsg = errorString(fbErr);
             throw new Error(`TempDir.create: tmpdir() at ${tmpdir()} was not writable (${primaryMsg}); ` +
                 `user-owned fallback ${fbRoot} also failed (${fbMsg}). ` +
-                `Most common cause: TMPDIR inherited from a sudo session — start a fresh shell.`);
+                `Most common cause: TMPDIR inherited from a sudo session — start a fresh shell.`, { cause: fbErr });
         }
     }
 }

package/dist/utils/tool-helpers.js

@@ -17,6 +17,17 @@ export function toolErrorResult(prefix, error) {
         isError: true,
     };
 }
+export function unknownDiscriminator(kind, value, allowed) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Error: unknown ${kind} "${String(value)}". Allowed: ${allowed.join(', ')}.`,
+            },
+        ],
+        isError: true,
+    };
+}
 export async function runSnippetTool(spec) {
     try {
         const args = validateArgs(spec.schema, spec.rawArgs);
@@ -41,3 +52,15 @@ export function applyToActiveLayerProp(op) {
         default: false,
     };
 }
+export function asSmartFilterProp() {
+    return {
+        type: 'boolean',
+        description: 'If true, apply the filter as a re-editable SMART FILTER riding the Smart Object ' +
+            'instead of baking it into pixels — nothing is rasterized, and the filter can later be ' +
+            'toggled, re-blended or removed instead of being permanent. Requires the target to be a ' +
+            'Smart Object (convert first with ps_convert_to_smart_object); errors rather than ' +
+            'converting silently. If false (default), the filter is baked and a smart-object layer ' +
+            'is rasterized first.',
+        default: false,
+    };
+}

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '1.0.3';
+export const VERSION = '1.2.0';

package/package.json

@@ -1,8 +1,19 @@
 {
   "name": "editmamei",
-  "version": "1.0.3",
+  "version": "1.2.0",
   "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"
+      ]
+    }
+  },
   "main": "dist/index.js",
   "type": "module",
   "bin": {
@@ -45,7 +56,7 @@
     "url": "https://github.com/editmamei/editmamei/issues"
   },
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=22.0.0"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.4",