editmamei 1.7.0 → 1.7.1

package/README.md

@@ -81,7 +81,7 @@ These are the choices that shape the surface, and the reason an AI assistant can
 
 ## Tool surface
 
-**111 tools total.** The Photoshop surface is **87 tools across 16 capability groups** (62 Community, 25 Pro), every one namespaced `ps_*` and discoverable at runtime via `tools/list`. Community tools ship in both editions; Pro tools unlock with a license. Alongside it, a second, independent editor surface drives headless GIMP: **24 `gimp_*` tools, Community, currently in beta**, see [GIMP (beta)](#gimp-beta) below. Pro's additions are Photoshop-only; GIMP has no Pro tier.
+**107 tools total.** The Photoshop surface is **83 tools across 16 capability groups** (62 Community, 21 Pro), covering the work in groups rather than one tool per Photoshop feature. Every one is namespaced `ps_*` and discoverable at runtime via `tools/list`. Community tools ship in both editions; Pro tools unlock with a license. Alongside it, a second, independent editor surface drives headless GIMP: **24 `gimp_*` tools, Community, currently in beta**, see [GIMP (beta)](#gimp-beta) below. Pro's additions are Photoshop-only; GIMP has no Pro tier.
 
 | Group | Edition | Tools |
 | --- | --- | --- |
@@ -116,7 +116,7 @@ These are the choices that shape the surface, and the reason an AI assistant can
 ## Editions
 
 - **Community** is free and covers the everyday editing surface: documents, layers, selections (including AI Select Subject and Select Sky), non-destructive adjustments, filters, masks, type, retouching, on-device perception, and the inspect/verify primitives.
-- **Pro** adds Camera Raw develop, the grounded precision tools (warp, named-object masks, precision placement), subject-instance targeting, face-mesh perception, the reproducible-template system, and Photoshop Actions plus the scripting escape hatch.
+- **Pro** adds Camera Raw as a re-editable filter, raw files developed before they open, folder batch, the reproducible-template system, the grounded precision tools (warp, named-object masks, precision placement), subject-instance and face-mesh targeting, and Photoshop Actions plus the scripting escape hatch.
 
 Pro is a Photoshop-only upgrade: it adds nothing to the GIMP surface below.
 
@@ -128,7 +128,7 @@ This repository holds the Community source. Pro is a separately licensed module
 
 Editmamei can also drive GIMP, headless, as a second editor alongside (or instead of) Photoshop. When GIMP 3.2+ is detected on your machine, a `gimp_*` tool set registers next to the `ps_*` one; use it when you ask for GIMP, or when Photoshop isn't available. There's no visible window: edits happen in a background `gimp-console` process, and you follow along through rendered previews in the conversation instead of watching a window change.
 
-The beta covers documents (open, create, save `.xcf`, export), layers and groups, placing one photo into another, 13 non-destructive adjustment types and six effects (vignette, black and white, motion and lens blur, noise, drop shadow), geometric masks, crop/resize/rotate/flip, canvas extension, colour/grayscale conversion, checkpoints you can restore, and the same preview/histogram/compare verification primitives the Photoshop side has. It doesn't yet cover heal/clone, AI subject or sky selection, or text. Full details, requirements, and troubleshooting: [docs/gimp.md](docs/gimp.md).
+The beta covers documents (open, create, save `.xcf`, export), layers and groups, placing one photo into another, 13 non-destructive adjustment types and six effects (vignette, black and white, motion and lens blur, noise, drop shadow), geometric masks, crop/resize/rotate/flip, canvas extension, color/grayscale conversion, checkpoints you can restore, and the same preview/histogram/compare verification primitives the Photoshop side has. It doesn't yet cover heal/clone, AI subject or sky selection, or text. Full details, requirements, and troubleshooting: [docs/gimp.md](docs/gimp.md).
 
 ## Build from source
 
@@ -170,6 +170,7 @@ The source in this repository is the same code published to npm, so none of the
 - **Install:** [docs/installation.md](docs/installation.md)
 - **Getting started:** [docs/getting-started.md](docs/getting-started.md)
 - **FAQ:** [docs/faq.md](docs/faq.md)
+- **AI clients:** [docs/clients.md](docs/clients.md)
 - **Troubleshooting:** [docs/troubleshooting.md](docs/troubleshooting.md)
 - **GIMP (beta):** [docs/gimp.md](docs/gimp.md)
 - **Pro features:** [docs/pro-features.md](docs/pro-features.md)

package/dist/cli/help.js

@@ -27,8 +27,8 @@ Install options:
 
   --skip-skill               Skip copying the editmamei skill bundle to your Downloads folder.
                              By default, install drops editmamei-skill.zip in Downloads with
-                             instructions for uploading it to claude.ai (Settings > Customize >
-                             Skills). Pass this flag for headless / CI installs where the skill
+                             instructions for uploading it to claude.ai (Settings > Skills).
+                             Pass this flag for headless / CI installs where the skill
                              upload step doesn't apply.
 
 Config examples:

package/dist/cli/install.js

@@ -61,8 +61,8 @@ export async function runInstall(opts = {}) {
     }
     if (skillResult?.status === 'copied') {
         out(`  2. Upload the editmamei skill to your Claude account:\n`);
-        out(`       - Open https://claude.ai/settings (Customize > Skills)\n`);
-        out(`       - Click "Upload skill"\n`);
+        out(`       - Open https://claude.ai/settings (Settings > Skills)\n`);
+        out(`       - Click Add, then "Upload skill"\n`);
         out(`       - Choose the file at ${skillResult.destPath}\n`);
         out(`     The skill auto-loads in any photo-editing conversation. It's a one-time upload.\n`);
         out(`  3. Then ask the AI: "Is Photoshop connected?" — it will call ps_ping and return your Photoshop version.\n`);

package/dist/install-channel.js

@@ -30,6 +30,8 @@ export function resolveInstallChannel(env = process.env, edition = EDITION, argv
         return 'dev';
     if (env.EDITMAMEI_INSTALL_CHANNEL === 'mcpb')
         return 'mcpb';
+    if (env.EDITMAMEI_INSTALL_CHANNEL === 'plugin')
+        return 'plugin';
     const trimmedArgv1 = argv1?.trim();
     if (!trimmedArgv1)
         return 'unknown';

package/dist/telemetry/client.js

@@ -7,7 +7,7 @@ import { READ_ONLY_TOOLS, KEPT_WORK_TOOLS, nodeMajor, archToken, osMajor, boundM
 import { buildClientConnected, buildDiagnosticEvent, buildModuleStatus, buildSessionStart, buildSessionSummary, buildUsageEvent, dayBucket, normalizeDayBucket, isContentSafe, PS_VERSION_UNKNOWN, } from './events.js';
 import { sanitizeMessage, sanitizeSnippet, sanitizeStderrTail } from './sanitize.js';
 import { httpTransport, resolveEndpoint } from './transport.js';
-import { appendOutboxSync, clearOutbox, clearSessionState, readOutboxWithDiscards, readSessionState, rewriteOutbox, writeSessionStateSync, } from './outbox.js';
+import { appendOutboxSync, claimOrphanedSessionStates, claimOutboxForDrain, clearSessionState, writeSessionStateSync, } from './outbox.js';
 const MAX_BATCH_SIZE = 100;
 const MAX_QUEUE_SIZE = 500;
 const DEFAULT_FLUSH_INTERVAL_MS = 5 * 60_000;
@@ -50,6 +50,8 @@ export class TelemetryClient {
     moduleUpdate = 'none';
     installAssets = {};
     lastSessionPersistMs = 0;
+    sessionStatePersisted = false;
+    startupFlushStarted = false;
     startDayBucket = null;
     constructor(opts) {
         this.settings = opts.settings;
@@ -59,7 +61,11 @@ export class TelemetryClient {
         this.flushIntervalMs = opts.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS;
         this.maxBatchSize = opts.maxBatchSize ?? MAX_BATCH_SIZE;
         this.active = opts.active ?? (EDITION !== 'dev' && !isTestEnv());
-        this.outboxOpts = opts.outboxDir ? { dir: opts.outboxDir } : {};
+        this.outboxOpts = {
+            ...(opts.outboxDir ? { dir: opts.outboxDir } : {}),
+            ...(opts.outboxPid !== undefined ? { pid: opts.outboxPid } : {}),
+            ...(opts.isPidAlive ? { isPidAlive: opts.isPidAlive } : {}),
+        };
         this.getModuleStatus = opts.getModuleStatus ?? (() => null);
         this.dims = {
             install_id: this.settings.telemetry.install_id,
@@ -200,6 +206,7 @@ export class TelemetryClient {
             ...this.summaryFields(),
         };
         writeSessionStateSync(state, this.outboxOpts);
+        this.sessionStatePersisted = true;
     }
     onPsVersionResolved() {
         if (!this.active || !this.settings.telemetry.usage || this.toolCallCount === 0)
@@ -297,22 +304,27 @@ export class TelemetryClient {
         clearSessionState(this.outboxOpts);
     }
     async flushOutboxOnStartup() {
-        if (!this.active)
+        if (!this.active || this.startupFlushStarted)
             return;
+        this.startupFlushStarted = true;
         try {
-            const stale = readSessionState(this.outboxOpts);
-            if (stale && this.settings.telemetry.usage && stale.tool_call_count > 0) {
-                appendOutboxSync([summaryFromState(stale)], this.outboxOpts);
+            const orphans = claimOrphanedSessionStates(this.outboxOpts, {
+                includeOwn: !this.sessionStatePersisted,
+            });
+            if (this.settings.telemetry.usage) {
+                const summaries = orphans.states.filter((s) => s.tool_call_count > 0).map(summaryFromState);
+                this.droppedOutbox += appendOutboxSync(summaries, this.outboxOpts);
             }
-            clearSessionState(this.outboxOpts);
-            const { events: pending, discarded } = readOutboxWithDiscards(this.outboxOpts);
+            orphans.release();
+            const claimed = claimOutboxForDrain(this.outboxOpts);
+            const { events: pending, discarded } = claimed;
             this.droppedOutbox += discarded;
             if (pending.length === 0) {
-                clearOutbox(this.outboxOpts);
+                claimed.release([]);
                 return;
             }
             if (!this.settings.telemetry.usage) {
-                clearOutbox(this.outboxOpts);
+                claimed.release([]);
                 return;
             }
             const sendable = pending.filter(isContentSafe);
@@ -330,12 +342,7 @@ export class TelemetryClient {
                 }
                 settled = i + batch.length;
             }
-            if (settled >= sendable.length) {
-                clearOutbox(this.outboxOpts);
-            }
-            else {
-                rewriteOutbox(sendable.slice(settled), this.outboxOpts);
-            }
+            this.droppedOutbox += claimed.release(sendable.slice(settled));
         }
         catch (err) {
             this.logger.debug(`startup outbox flush error: ${errMsg(err)}`);

package/dist/telemetry/outbox.js

@@ -1,21 +1,86 @@
 import { homedir } from 'node:os';
 import { join, dirname } from 'node:path';
-import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, appendFileSync, statSync, rmSync, } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, renameSync, appendFileSync, statSync, rmSync, } from 'node:fs';
 import { Logger } from '../utils/logger.js';
 const logger = new Logger('TelemetryOutbox');
 const DIRNAME = '.editmamei';
 const OUTBOX_FILENAME = 'telemetry-outbox.ndjson';
-const SESSION_STATE_FILENAME = 'telemetry-session.json';
+const LEGACY_SESSION_STATE_FILENAME = 'telemetry-session.json';
+const SESSION_STATE_RE = /^telemetry-session\.(\d+)\.json$/;
+const RECOVER_RE = /^\.session-recover\.(\d+)\.(telemetry-session(?:\.\d+)?\.json)$/;
+const CLAIM_RE = /^telemetry-outbox\.(?:draining|compacting)\.(\d+)\.(\d+)\.ndjson$/;
 export const MAX_OUTBOX_EVENTS = 5_000;
 export const MAX_OUTBOX_BYTES = 2_000_000;
+export function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err.code === 'EPERM';
+    }
+}
 function baseDir(opts) {
     return opts.dir ?? join(homedir(), DIRNAME);
 }
 export function outboxPath(opts = {}) {
     return join(baseDir(opts), OUTBOX_FILENAME);
 }
+function ownPid(opts) {
+    return opts.pid ?? process.pid;
+}
 export function sessionStatePath(opts = {}) {
-    return join(baseDir(opts), SESSION_STATE_FILENAME);
+    return join(baseDir(opts), `telemetry-session.${ownPid(opts)}.json`);
+}
+function listDir(dir) {
+    try {
+        return readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+}
+function claim(from, to) {
+    try {
+        renameSync(from, to);
+        return to;
+    }
+    catch {
+        return null;
+    }
+}
+function freeClaimName(dir, kind, pid) {
+    for (let seq = 0;; seq++) {
+        const path = join(dir, `telemetry-outbox.${kind}.${pid}.${seq}.ndjson`);
+        if (!existsSync(path))
+            return path;
+    }
+}
+function readClaim(path) {
+    const buf = readFileSync(path);
+    const bytes = buf.lastIndexOf(0x0a) + 1;
+    return { ...parseOutbox(buf.subarray(0, bytes).toString('utf8')), bytes };
+}
+function readClaimTail(path, bytes) {
+    const buf = readFileSync(path);
+    if (buf.length <= bytes)
+        return { events: [], discarded: 0 };
+    return parseOutbox(buf.subarray(bytes).toString('utf8'));
+}
+function removeClaim(path, what) {
+    try {
+        rmSync(path, { force: true });
+        return;
+    }
+    catch (err) {
+        logger.debug(`${what} delete failed: ${errMsg(err)}`);
+    }
+    try {
+        writeFileSync(path, '');
+    }
+    catch (err) {
+        logger.debug(`${what} truncate failed: ${errMsg(err)}`);
+    }
 }
 function ensureDir(path) {
     mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
@@ -44,31 +109,100 @@ export function readOutboxWithDiscards(opts = {}) {
     if (!existsSync(path))
         return { events: [], discarded: 0 };
     try {
-        const raw = readFileSync(path, 'utf8');
-        const events = [];
-        let discarded = 0;
-        for (const line of raw.split('\n')) {
-            const trimmed = line.trim();
-            if (trimmed.length === 0)
-                continue;
-            try {
-                events.push(JSON.parse(trimmed));
-            }
-            catch {
-                discarded += 1;
-            }
-        }
-        if (events.length > MAX_OUTBOX_EVENTS) {
-            const over = events.length - MAX_OUTBOX_EVENTS;
-            return { events: events.slice(over), discarded: discarded + over };
-        }
-        return { events, discarded };
+        return boundOutbox(parseOutbox(readFileSync(path, 'utf8')));
     }
     catch (err) {
         logger.debug(`outbox read failed: ${errMsg(err)}`);
         return { events: [], discarded: 0 };
     }
 }
+function parseOutbox(raw) {
+    const events = [];
+    let discarded = 0;
+    for (const line of raw.split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed.length === 0)
+            continue;
+        try {
+            events.push(JSON.parse(trimmed));
+        }
+        catch {
+            discarded += 1;
+        }
+    }
+    return { events, discarded };
+}
+function boundOutbox({ events, discarded }) {
+    if (events.length <= MAX_OUTBOX_EVENTS)
+        return { events, discarded };
+    const over = events.length - MAX_OUTBOX_EVENTS;
+    return { events: events.slice(over), discarded: discarded + over };
+}
+export function claimOutboxForDrain(opts = {}) {
+    const dir = baseDir(opts);
+    const me = ownPid(opts);
+    const alive = opts.isPidAlive ?? isPidAlive;
+    const claimed = [];
+    const nextName = () => freeClaimName(dir, 'draining', me);
+    const abandoned = listDir(dir)
+        .flatMap((name) => {
+        const m = CLAIM_RE.exec(name);
+        return m ? [{ name, pid: Number(m[1]), seq: Number(m[2]) }] : [];
+    })
+        .filter((c) => c.pid === me || !alive(c.pid))
+        .sort((a, b) => a.pid - b.pid || a.seq - b.seq || a.name.localeCompare(b.name));
+    for (const c of abandoned) {
+        const from = join(dir, c.name);
+        const got = c.pid === me ? from : claim(from, nextName());
+        if (got)
+            claimed.push(got);
+    }
+    const live = claim(outboxPath(opts), nextName());
+    if (live)
+        claimed.push(live);
+    const consumed = [];
+    let read = { events: [], discarded: 0 };
+    for (const path of claimed) {
+        try {
+            const part = readClaim(path);
+            read = {
+                events: read.events.concat(part.events),
+                discarded: read.discarded + part.discarded,
+            };
+            consumed.push({ path, bytes: part.bytes });
+        }
+        catch (err) {
+            logger.debug(`claimed outbox read failed: ${errMsg(err)}`);
+        }
+    }
+    const { events, discarded } = boundOutbox(read);
+    let released = false;
+    return {
+        events,
+        discarded,
+        release(undelivered) {
+            if (released)
+                return 0;
+            released = true;
+            const late = [];
+            let lost = 0;
+            for (const { path, bytes } of consumed) {
+                try {
+                    const tail = readClaimTail(path, bytes);
+                    late.push(...tail.events);
+                    lost += tail.discarded;
+                }
+                catch (err) {
+                    logger.debug(`claimed outbox re-read failed: ${errMsg(err)}`);
+                }
+            }
+            lost += appendOutboxSync(undelivered.concat(late), opts);
+            for (const { path } of consumed)
+                removeClaim(path, 'claimed outbox');
+            return lost;
+        },
+    };
+}
 export function readOutbox(opts = {}) {
     return readOutboxWithDiscards(opts).events;
 }
@@ -88,7 +222,7 @@ export function rewriteOutbox(events, opts = {}) {
     const path = outboxPath(opts);
     try {
         ensureDir(path);
-        const tmp = join(dirname(path), `.outbox.${process.pid}.tmp`);
+        const tmp = join(dirname(path), `.outbox.${ownPid(opts)}.tmp`);
         writeFileSync(tmp, events.map((e) => JSON.stringify(e)).join('\n') + '\n', {
             encoding: 'utf8',
             mode: 0o600,
@@ -100,7 +234,18 @@ export function rewriteOutbox(events, opts = {}) {
     }
 }
 function compactOutbox(opts = {}) {
-    const { events, discarded } = readOutboxWithDiscards(opts);
+    const path = claim(outboxPath(opts), freeClaimName(baseDir(opts), 'compacting', ownPid(opts)));
+    if (!path)
+        return 0;
+    let read;
+    try {
+        read = readClaim(path);
+    }
+    catch (err) {
+        logger.debug(`compaction read failed, leaving the claim for recovery: ${errMsg(err)}`);
+        return 0;
+    }
+    const { events, discarded } = boundOutbox(read);
     const target = MAX_OUTBOX_BYTES / 2;
     let bytes = 0;
     let firstKept = Math.max(events.length - 1, 0);
@@ -111,14 +256,34 @@ function compactOutbox(opts = {}) {
         firstKept = i;
     }
     const kept = events.slice(firstKept);
-    rewriteOutbox(kept, opts);
-    return discarded + (events.length - kept.length);
+    let late = { events: [], discarded: 0 };
+    try {
+        late = readClaimTail(path, read.bytes);
+    }
+    catch (err) {
+        logger.debug(`compaction re-read failed: ${errMsg(err)}`);
+    }
+    const back = kept.concat(late.events);
+    if (back.length > 0) {
+        try {
+            appendFileSync(outboxPath(opts), back.map((e) => JSON.stringify(e)).join('\n') + '\n', {
+                encoding: 'utf8',
+                mode: 0o600,
+            });
+        }
+        catch (err) {
+            logger.debug(`compaction write-back failed, leaving the claim for recovery: ${errMsg(err)}`);
+            return 0;
+        }
+    }
+    removeClaim(path, 'compaction claim');
+    return discarded + (events.length - kept.length) + late.discarded;
 }
 export function writeSessionStateSync(state, opts = {}) {
     const path = sessionStatePath(opts);
     try {
         ensureDir(path);
-        const tmp = join(dirname(path), `.session.${process.pid}.tmp`);
+        const tmp = join(dirname(path), `.session.${ownPid(opts)}.tmp`);
         writeFileSync(tmp, JSON.stringify(state), { encoding: 'utf8', mode: 0o600 });
         renameSync(tmp, path);
     }
@@ -127,7 +292,62 @@ export function writeSessionStateSync(state, opts = {}) {
     }
 }
 export function readSessionState(opts = {}) {
-    const path = sessionStatePath(opts);
+    return readSessionStateAt(sessionStatePath(opts));
+}
+export function claimOrphanedSessionStates(opts = {}, { includeOwn }) {
+    const dir = baseDir(opts);
+    const me = ownPid(opts);
+    const alive = opts.isPidAlive ?? isPidAlive;
+    const takeable = (pid) => (pid === me ? includeOwn : !alive(pid));
+    const claimed = [];
+    for (const name of listDir(dir)) {
+        let original;
+        const r = RECOVER_RE.exec(name);
+        if (r) {
+            const pid = Number(r[1]);
+            if (!takeable(pid))
+                continue;
+            if (pid === me) {
+                claimed.push(join(dir, name));
+                continue;
+            }
+            original = r[2];
+        }
+        else if (name === LEGACY_SESSION_STATE_FILENAME) {
+            original = name;
+        }
+        else {
+            const m = SESSION_STATE_RE.exec(name);
+            if (!m || !takeable(Number(m[1])))
+                continue;
+            original = name;
+        }
+        const target = join(dir, `.session-recover.${me}.${original}`);
+        if (existsSync(target))
+            continue;
+        const got = claim(join(dir, name), target);
+        if (got)
+            claimed.push(got);
+    }
+    const states = [];
+    for (const path of claimed) {
+        const state = readSessionStateAt(path);
+        if (state)
+            states.push(state);
+    }
+    let released = false;
+    return {
+        states,
+        release() {
+            if (released)
+                return;
+            released = true;
+            for (const path of claimed)
+                removeClaim(path, 'session-state recover');
+        },
+    };
+}
+function readSessionStateAt(path) {
     if (!existsSync(path))
         return null;
     try {

package/dist/update/check.js

@@ -99,6 +99,8 @@ export function updateMessage(channel, latest) {
     switch (channel) {
         case 'mcpb':
             return `Download editmamei.mcpb (v${latest}) from ${RELEASES_URL} and reinstall the Claude Desktop extension.`;
+        case 'plugin':
+            return `Editmamei v${latest} is available. Update the Editmamei plugin in Claude, then restart.`;
         case 'dev':
             return `You're on a local dev build — pull the latest source and rebuild.`;
         case 'npx':

package/dist/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "editmamei",
-  "version": "1.7.0",
+  "version": "1.7.1",
   "description": "Photoshop MCP server: natural-language AI photo editing in desktop Photoshop (Community Edition)",
   "mcpName": "io.github.editmamei/editmamei",
   "editmamei": {