editmamei 1.4.0 → 1.5.0

package/dist/telemetry/client.js

@@ -1,8 +1,10 @@
+import { release } from 'node:os';
 import { Logger } from '../utils/logger.js';
 import { EDITION } from '../edition.js';
 import { VERSION } from '../version.js';
 import { resolveInstallChannel } from '../install-channel.js';
-import { buildDiagnosticEvent, buildModuleStatus, buildSessionStart, buildSessionSummary, buildUsageEvent, dayBucket, normalizeDayBucket, isContentSafe, PS_VERSION_UNKNOWN, } from './events.js';
+import { READ_ONLY_TOOLS, KEPT_WORK_TOOLS, nodeMajor, archToken, osMajor, boundMajor, } from './activity.js';
+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, readOutbox, readSessionState, writeSessionStateSync, } from './outbox.js';
@@ -10,6 +12,8 @@ const MAX_BATCH_SIZE = 100;
 const MAX_QUEUE_SIZE = 500;
 const DEFAULT_FLUSH_INTERVAL_MS = 5 * 60_000;
 const SESSION_PERSIST_THROTTLE_MS = 10_000;
+const MAX_SESSION_DURATION_S = 604_800;
+const MAX_INSTALL_ASSET_COUNT = 100_000;
 function isTestEnv() {
     return process.env.VITEST !== undefined || process.env.NODE_ENV === 'test';
 }
@@ -25,12 +29,23 @@ export class TelemetryClient {
     active;
     outboxOpts;
     getModuleStatus;
+    resolvedModuleStatus = null;
     queue = [];
     timer = null;
     shutdownPromise = null;
     toolCallCount = 0;
     distinctTools = new Set();
     anyFailures = false;
+    firstCallAtMs = null;
+    lastCallAtMs = null;
+    retryCount = 0;
+    lastCallSuccess = null;
+    editsOk = 0;
+    keptWork = 0;
+    droppedEvents = 0;
+    behindLatest = null;
+    moduleUpdate = 'none';
+    installAssets = {};
     lastSessionPersistMs = 0;
     startDayBucket = null;
     constructor(opts) {
@@ -61,24 +76,95 @@ export class TelemetryClient {
         this.timer = setInterval(() => void this.flush(), this.flushIntervalMs);
         this.timer.unref?.();
         if (this.settings.telemetry.usage) {
-            this.enqueue(buildSessionStart(this.dims, this.now()));
-            const moduleStatus = this.getModuleStatus();
+            const hostNodeMajor = boundMajor(nodeMajor(), 999);
+            const hostOsMajor = boundMajor(osMajor(process.platform, release()), 999);
+            this.enqueue(buildSessionStart(this.dims, this.now(), {
+                ...(hostNodeMajor !== null ? { node_major: hostNodeMajor } : {}),
+                arch: archToken(),
+                ...(hostOsMajor !== null ? { os_major: hostOsMajor } : {}),
+            }));
+            const moduleStatus = this.moduleStatus();
             if (moduleStatus)
                 this.enqueue(buildModuleStatus(this.dims, moduleStatus, this.now()));
             void this.flush();
         }
     }
+    recordClientConnected(info) {
+        if (!this.active || !this.settings.telemetry.usage)
+            return;
+        this.enqueue(buildClientConnected(this.dims, info, this.now()));
+    }
     recordCall(call) {
         if (!this.active || !this.settings.telemetry.usage)
             return;
         this.ensureStartDayBucket();
+        const nowDate = this.now();
+        const nowMs = nowDate.getTime();
         this.toolCallCount += 1;
         this.distinctTools.add(call.tool);
         if (!call.success)
             this.anyFailures = true;
-        this.enqueue(buildUsageEvent(this.dims, call, this.now()));
+        this.lastCallSuccess = call.success;
+        if (call.retry)
+            this.retryCount += 1;
+        if (call.success) {
+            if (!READ_ONLY_TOOLS.has(call.tool))
+                this.editsOk += 1;
+            if (KEPT_WORK_TOOLS.has(call.tool))
+                this.keptWork += 1;
+        }
+        if (this.firstCallAtMs === null)
+            this.firstCallAtMs = nowMs;
+        this.lastCallAtMs = nowMs;
+        this.enqueue(buildUsageEvent(this.dims, call, nowDate));
         this.persistSessionStateThrottled();
     }
+    setBehindLatest(value) {
+        this.behindLatest = value;
+    }
+    setModuleUpdate(outcome) {
+        this.moduleUpdate = outcome;
+    }
+    setInstallAssets(assets) {
+        const templatesSaved = assets.templates_saved !== undefined ? clampCount(assets.templates_saved) : null;
+        const actionSets = assets.action_sets !== undefined ? clampCount(assets.action_sets) : null;
+        this.installAssets = {
+            ...this.installAssets,
+            ...(templatesSaved !== null ? { templates_saved: templatesSaved } : {}),
+            ...(actionSets !== null ? { action_sets: actionSets } : {}),
+        };
+    }
+    moduleStatus() {
+        if (this.resolvedModuleStatus === null) {
+            this.resolvedModuleStatus = { value: this.getModuleStatus() };
+        }
+        return this.resolvedModuleStatus.value;
+    }
+    durationS() {
+        if (this.firstCallAtMs === null || this.lastCallAtMs === null)
+            return undefined;
+        return Math.min(Math.max(0, Math.floor((this.lastCallAtMs - this.firstCallAtMs) / 1000)), MAX_SESSION_DURATION_S);
+    }
+    summaryFields() {
+        const duration = this.durationS();
+        const moduleStatus = this.moduleStatus();
+        return {
+            ...(duration !== undefined ? { duration_s: duration } : {}),
+            retry_count: this.retryCount,
+            ...(this.lastCallSuccess !== null ? { ended_after_failure: !this.lastCallSuccess } : {}),
+            edits_ok: this.editsOk,
+            kept_work: this.keptWork,
+            ...(this.behindLatest !== null ? { behind_latest: this.behindLatest } : {}),
+            dropped_events: this.droppedEvents,
+            ...(moduleStatus !== null ? { module_update: this.moduleUpdate } : {}),
+            ...(this.installAssets.templates_saved !== undefined
+                ? { templates_saved: this.installAssets.templates_saved }
+                : {}),
+            ...(this.installAssets.action_sets !== undefined
+                ? { action_sets: this.installAssets.action_sets }
+                : {}),
+        };
+    }
     psVersion() {
         const v = this.dims.getPsVersion();
         return v && v.length > 0 ? v : PS_VERSION_UNKNOWN;
@@ -105,6 +191,7 @@ export class TelemetryClient {
             tool_call_count: this.toolCallCount,
             distinct_tools: this.distinctTools.size,
             any_failures: this.anyFailures,
+            ...this.summaryFields(),
         };
         writeSessionStateSync(state, this.outboxOpts);
     }
@@ -123,6 +210,9 @@ export class TelemetryClient {
             error_message: sanitizeMessage(diag.error_message),
             ...(diag.snippet ? { snippet: sanitizeSnippet(diag.snippet) } : {}),
             ...(diag.stderr_tail ? { stderr_tail: sanitizeStderrTail(diag.stderr_tail) } : {}),
+            ...(diag.doc_depth !== undefined ? { doc_depth: diag.doc_depth } : {}),
+            ...(diag.doc_mode !== undefined ? { doc_mode: diag.doc_mode } : {}),
+            ...(diag.ps_locale !== undefined ? { ps_locale: diag.ps_locale } : {}),
         }, this.now()));
     }
     restampPsVersion(events) {
@@ -141,7 +231,9 @@ export class TelemetryClient {
     enqueue(event) {
         this.queue.push(event);
         if (this.queue.length > MAX_QUEUE_SIZE) {
-            this.queue.splice(0, this.queue.length - MAX_QUEUE_SIZE);
+            const excess = this.queue.length - MAX_QUEUE_SIZE;
+            this.queue.splice(0, excess);
+            this.droppedEvents += excess;
         }
         if (this.queue.length >= this.maxBatchSize)
             void this.flush();
@@ -177,6 +269,7 @@ export class TelemetryClient {
                 tool_call_count: this.toolCallCount,
                 distinct_tools: this.distinctTools.size,
                 any_failures: this.anyFailures,
+                ...this.summaryFields(),
             }, this.ensureStartDayBucket(), this.now()));
         }
         if (this.queue.length > 0) {
@@ -228,6 +321,8 @@ export class TelemetryClient {
     }
 }
 function summaryFromState(s) {
+    const templatesSaved = s.templates_saved !== undefined ? clampCount(s.templates_saved) : null;
+    const actionSets = s.action_sets !== undefined ? clampCount(s.action_sets) : null;
     return {
         v: 2,
         type: 'session_summary',
@@ -240,8 +335,23 @@ function summaryFromState(s) {
         tool_call_count: s.tool_call_count,
         distinct_tools: s.distinct_tools,
         any_failures: s.any_failures,
+        ...(s.duration_s !== undefined ? { duration_s: s.duration_s } : {}),
+        ...(s.retry_count !== undefined ? { retry_count: s.retry_count } : {}),
+        ...(s.ended_after_failure !== undefined ? { ended_after_failure: s.ended_after_failure } : {}),
+        ...(s.edits_ok !== undefined ? { edits_ok: s.edits_ok } : {}),
+        ...(s.kept_work !== undefined ? { kept_work: s.kept_work } : {}),
+        ...(s.behind_latest !== undefined ? { behind_latest: s.behind_latest } : {}),
+        ...(s.dropped_events !== undefined ? { dropped_events: s.dropped_events } : {}),
+        ...(s.module_update !== undefined ? { module_update: s.module_update } : {}),
+        ...(templatesSaved !== null ? { templates_saved: templatesSaved } : {}),
+        ...(actionSets !== null ? { action_sets: actionSets } : {}),
     };
 }
 function errMsg(err) {
     return err instanceof Error ? err.message : String(err);
 }
+function clampCount(n) {
+    if (!Number.isFinite(n))
+        return null;
+    return Math.min(Math.max(0, Math.trunc(n)), MAX_INSTALL_ASSET_COUNT);
+}

package/dist/telemetry/events.js

@@ -1,5 +1,8 @@
+import { mapClientName, parseMajor, boundMajor } from './activity.js';
 export const TELEMETRY_SCHEMA_VERSION = 2;
 export const PS_VERSION_UNKNOWN = 'unknown';
+export const MAX_RESULT_BYTES = 16_777_216;
+const PS_LOCALE_RE = /^[a-z]{2,3}_[A-Z]{2}$/;
 export function dayBucket(now) {
     return now.toISOString().slice(0, 10);
 }
@@ -31,6 +34,9 @@ export function buildUsageEvent(dims, call, now) {
         success: call.success,
         error_class: call.error_class === null ? null : normalizeErrorClass(call.error_class),
         duration_ms: call.duration_ms,
+        ...(call.result_bytes !== undefined
+            ? { result_bytes: Math.min(call.result_bytes, MAX_RESULT_BYTES) }
+            : {}),
     };
 }
 export function buildSessionSummary(dims, summary, tsBucket, now) {
@@ -46,9 +52,21 @@ export function buildSessionSummary(dims, summary, tsBucket, now) {
         tool_call_count: summary.tool_call_count,
         distinct_tools: summary.distinct_tools,
         any_failures: summary.any_failures,
+        ...(summary.duration_s !== undefined ? { duration_s: summary.duration_s } : {}),
+        ...(summary.retry_count !== undefined ? { retry_count: summary.retry_count } : {}),
+        ...(summary.ended_after_failure !== undefined
+            ? { ended_after_failure: summary.ended_after_failure }
+            : {}),
+        ...(summary.edits_ok !== undefined ? { edits_ok: summary.edits_ok } : {}),
+        ...(summary.kept_work !== undefined ? { kept_work: summary.kept_work } : {}),
+        ...(summary.behind_latest !== undefined ? { behind_latest: summary.behind_latest } : {}),
+        ...(summary.dropped_events !== undefined ? { dropped_events: summary.dropped_events } : {}),
+        ...(summary.module_update !== undefined ? { module_update: summary.module_update } : {}),
+        ...(summary.templates_saved !== undefined ? { templates_saved: summary.templates_saved } : {}),
+        ...(summary.action_sets !== undefined ? { action_sets: summary.action_sets } : {}),
     };
 }
-export function buildSessionStart(dims, now) {
+export function buildSessionStart(dims, now, facts = {}) {
     return {
         v: TELEMETRY_SCHEMA_VERSION,
         type: 'session_start',
@@ -59,6 +77,25 @@ export function buildSessionStart(dims, now) {
         platform: dims.platform,
         ps_version: psVersionOf(dims),
         channel: dims.channel,
+        ...(facts.node_major !== undefined ? { node_major: facts.node_major } : {}),
+        ...(facts.arch !== undefined ? { arch: facts.arch } : {}),
+        ...(facts.os_major !== undefined ? { os_major: facts.os_major } : {}),
+    };
+}
+export function buildClientConnected(dims, info, now) {
+    return {
+        v: TELEMETRY_SCHEMA_VERSION,
+        type: 'client_connected',
+        install_id: dims.install_id,
+        ts_bucket: dayBucket(now),
+        editmamei_version: dims.editmamei_version,
+        edition: dims.edition,
+        platform: dims.platform,
+        client: mapClientName(info.clientName),
+        client_major: boundMajor(parseMajor(info.clientVersion), 9999),
+        cap_sampling: info.capSampling,
+        cap_elicitation: info.capElicitation,
+        cap_roots: info.capRoots,
     };
 }
 export function buildModuleStatus(dims, status, now) {
@@ -90,6 +127,11 @@ export function buildDiagnosticEvent(dims, diag, now) {
         error_message: diag.error_message,
         ...(diag.snippet ? { snippet: diag.snippet } : {}),
         ...(diag.stderr_tail ? { stderr_tail: diag.stderr_tail } : {}),
+        ...(diag.doc_depth !== undefined ? { doc_depth: diag.doc_depth } : {}),
+        ...(diag.doc_mode !== undefined ? { doc_mode: diag.doc_mode } : {}),
+        ...(diag.ps_locale !== undefined && PS_LOCALE_RE.test(diag.ps_locale)
+            ? { ps_locale: diag.ps_locale }
+            : {}),
     };
 }
 export function looksLikeAbsolutePath(value) {

package/dist/tools/document-tools.js

@@ -83,6 +83,11 @@ const openDocumentSchema = {
             description: 'Suppress all PS dialogs during open (raw/HEIC use last-used ACR settings). Default true for pipeline use.',
             default: true,
         },
+        bit_depth: {
+            type: 'number',
+            enum: [8, 16],
+            description: 'Open-time bits per channel, RAW sources only. Set this here rather than converting later: ps_convert_image_mode FLATTENS the document, so depth cannot be changed once an edit stack exists. Prefer 16 for anything with heavy gradients (skies, skin, long tonal moves). Ignored for non-raw files, and the returned bits_per_channel always reports what was actually opened.',
+        },
     },
     required: ['file_path'],
 };
@@ -294,6 +299,10 @@ export function createDocumentTools(connection, snippetClient) {
                         },
                         already_open: { type: 'boolean' },
                         file_path: { type: 'string' },
+                        bit_depth_warning: {
+                            type: 'string',
+                            description: 'Present only when a requested bit_depth was not what the document actually opened at — because the file is not a raw source, or Photoshop declined the requested depth. Absent means bits_per_channel is what you asked for.',
+                        },
                         context: { type: 'object' },
                     },
                     required: ['success'],
@@ -524,8 +533,21 @@ async function openDocumentPipeline(connection, snippetClient, rawArgs) {
         const args = validateArgs(openDocumentSchema, rawArgs);
         filePath = args.file_path;
         const suppressDialogs = args.suppress_dialogs;
-        const script = await snippetClient.build('openDocumentPipeline', { filePath, suppressDialogs });
+        const bitDepth = args.bit_depth;
+        const script = await snippetClient.build('openDocumentPipeline', {
+            filePath,
+            suppressDialogs,
+            rawBits: bitDepth ?? 0,
+        });
         const result = await runScript(connection, script, OPEN_DOCUMENT_TIMEOUT_MS);
+        const payload = result;
+        if (bitDepth !== undefined && typeof payload.bits_per_channel === 'number') {
+            if (payload.bits_per_channel !== bitDepth) {
+                payload.bit_depth_warning = payload.is_raw_source
+                    ? `Requested ${bitDepth}-bit but Photoshop opened ${payload.bits_per_channel}-bit.`
+                    : `bit_depth applies to RAW sources only; this file opened at ${payload.bits_per_channel}-bit.`;
+            }
+        }
         return {
             content: [
                 {

package/dist/update/check.js

@@ -101,7 +101,15 @@ export function updateMessage(channel, latest) {
             return `Download editmamei.mcpb (v${latest}) from ${RELEASES_URL} and reinstall the Claude Desktop extension.`;
         case 'dev':
             return `You're on a local dev build — pull the latest source and rebuild.`;
-        case 'npm':
+        case 'npx':
+            return `The next \`npx -y editmamei\` picks up v${latest} automatically — just restart your AI client.`;
+        case 'source':
+            return `You're running Editmamei from a source checkout — pull the latest changes and rebuild.`;
+        case 'npm_local':
+            return `Editmamei is installed locally in a project — update the \`editmamei\` dependency in that project (e.g. \`npm install editmamei@latest\`) and restart your MCP client.`;
+        case 'unknown':
+            return `Editmamei v${latest} is available. Update it the way you installed it, then restart your MCP client.`;
+        case 'npm_global':
         default:
             return `Run: npm install -g editmamei@latest (then restart your MCP client).`;
     }
@@ -110,7 +118,7 @@ export function shouldCheckForUpdate(updateCheckEnabled, env = process.env) {
     const inTest = env.VITEST !== undefined || env.NODE_ENV === 'test';
     return updateCheckEnabled === true && !inTest;
 }
-export async function checkForUpdate(opts = {}) {
+export async function checkForUpdateWithStatus(opts = {}) {
     try {
         const env = opts.env ?? process.env;
         const current = opts.current ?? VERSION;
@@ -118,19 +126,25 @@ export async function checkForUpdate(opts = {}) {
         const fetchLatest = opts.fetchLatest ?? httpFetchLatest();
         const manifest = await fetchLatest(resolveUpdateCheckUrl(env), opts.timeoutMs ?? 4000);
         if (!manifest || !parseSemver(manifest.version))
-            return null;
+            return { status: 'failed', info: null };
         const latest = manifest.version;
         if (!isNewer(latest, current))
-            return null;
+            return { status: 'current', info: null };
         return {
-            current,
-            latest,
-            channel,
-            how_to_update: updateMessage(channel, latest),
-            fixed_tools: fixedToolsSince(manifest.fixesByVersion, current, latest),
+            status: 'newer',
+            info: {
+                current,
+                latest,
+                channel,
+                how_to_update: updateMessage(channel, latest),
+                fixed_tools: fixedToolsSince(manifest.fixesByVersion, current, latest),
+            },
         };
     }
     catch {
-        return null;
+        return { status: 'failed', info: null };
     }
 }
+export async function checkForUpdate(opts = {}) {
+    return (await checkForUpdateWithStatus(opts)).info;
+}

package/dist/utils/session-log.js

@@ -267,7 +267,7 @@ export class SessionLog {
         this.metaEmitted = true;
         await this.writeLine(JSON.stringify(this.buildMetaEntry()));
     }
-    async append(entry, result) {
+    async append(entry, result, resultBytes) {
         if (!this.metaEmitted) {
             await this.emitMeta();
         }
@@ -277,7 +277,7 @@ export class SessionLog {
         const callKey = JSON.stringify({ tool: entry.tool, args: sanitizedArgs });
         const retrySignal = callKey === this.lastCallKey;
         this.lastCallKey = callKey;
-        const resultBytes = computeResultBytes(result);
+        const finalResultBytes = resultBytes !== undefined ? resultBytes : computeResultBytes(result);
         let hoisted = {};
         try {
             hoisted = hoistContextScalars(result);
@@ -302,7 +302,7 @@ export class SessionLog {
             edition: EDITION,
             platform: process.platform,
             ps_version: this.psVersion,
-            result_bytes: resultBytes,
+            result_bytes: finalResultBytes,
             ...hoisted,
             ...(errorClass !== null ? { error_class: errorClass } : {}),
             retry_signal: retrySignal,