editmamei 0.18.0 → 0.20.0

package/README.md

@@ -125,7 +125,7 @@ Editmamei runs on your computer and edits in your own Photoshop. No image conten
 
 - **Features and pricing:** [editmamei.com](https://editmamei.com)
 - **Install, getting started, FAQ, Pro features:** [the wiki](https://github.com/editmamei/editmamei-wiki)
-- **Bugs and feature requests:** [the issue tracker](https://github.com/editmamei/editmamei-wiki/issues)
+- **Bugs and feature requests:** [the issue tracker](https://github.com/editmamei/editmamei-wiki/issues). If something's broken, ask your assistant to "report a problem" (or run `editmamei report`) to drop an anonymized diagnostic bundle in your Downloads folder, then attach it to the issue.
 - **Security:** see [editmamei.com/security](https://editmamei.com/security) (don't file security issues publicly)
 
 ## License

package/dist/cli/config.js

@@ -43,6 +43,13 @@ const KEYS = {
         },
         coerce: coercePath,
     },
+    update_check: {
+        get: (s) => s.update_check,
+        set: (s, v) => {
+            s.update_check = v;
+        },
+        coerce: coerceBool,
+    },
 };
 function knownKeysHint() {
     return `Known keys:\n${Object.keys(KEYS)

package/dist/cli/help.js

@@ -10,6 +10,7 @@ Usage:
   editmamei activate <key>   Activate a Pro license on this device
   editmamei deactivate       Free this device's seat (before moving Pro to another machine)
   editmamei license          Show the current license + whether Pro is unlocked
+  editmamei report           Write an anonymized diagnostic bundle to Downloads for a bug report
   editmamei help, --help     Print this help
 
 Install options:
@@ -33,6 +34,9 @@ Config examples:
   editmamei config set telemetry.usage false     Opt out of anonymous usage telemetry
   editmamei config set telemetry.diagnostics true Opt in to sanitized diagnostic detail
 
+Report options:
+  --note "<text>"            Attach a short description of the problem to the bundle
+
 Examples:
   npm install -g editmamei && editmamei install
   editmamei install --photoshop-path "D:\\Adobe\\Photoshop 2025\\Photoshop.exe"

package/dist/cli/report.js

@@ -0,0 +1,11 @@
+import { collectDiagnostics, writeDiagnosticBundle, ISSUES_URL } from '../diagnostics/collect.js';
+export async function runReport(opts = {}) {
+    const out = opts.stdout ?? ((s) => process.stdout.write(s));
+    const collect = opts.collect ?? collectDiagnostics;
+    const write = opts.write ?? writeDiagnosticBundle;
+    const bundle = await collect({ note: opts.note });
+    const { path } = await write(bundle);
+    out(`\n  Wrote an anonymized diagnostic bundle to:\n    ${path}\n\n`);
+    out(`  It contains recent logs + system info — no images, no full file paths, no tool arguments.\n`);
+    out(`  Attach this file to a new issue at ${ISSUES_URL} so the maintainers can debug.\n\n`);
+}

package/dist/cli/router.js

@@ -5,6 +5,7 @@ import { runConfig } from './config.js';
 import { runActivate } from './activate.js';
 import { runDeactivate } from './deactivate.js';
 import { runLicenseStatus } from './license.js';
+import { runReport } from './report.js';
 import { printHelp } from './help.js';
 import { Logger } from '../utils/logger.js';
 const logger = new Logger('CLI');
@@ -41,6 +42,9 @@ export async function routeCli(argv, opts = {}) {
             case 'license':
                 await runLicenseStatus();
                 return { handled: true, exitCode: 0 };
+            case 'report':
+                await runReport({ note: parseNoteOpt(argv.slice(1)) });
+                return { handled: true, exitCode: 0 };
             case 'help':
             case '--help':
             case '-h':
@@ -58,6 +62,22 @@ export async function routeCli(argv, opts = {}) {
         return { handled: true, exitCode: 1 };
     }
 }
+function parseNoteOpt(args) {
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--note') {
+            const value = args[i + 1];
+            if (value && !value.startsWith('--'))
+                return value;
+            return undefined;
+        }
+        if (a.startsWith('--note=')) {
+            const value = a.slice('--note='.length);
+            return value.length > 0 ? value : undefined;
+        }
+    }
+    return undefined;
+}
 function parseInstallOpts(args, err) {
     const opts = {};
     for (let i = 0; i < args.length; i++) {

package/dist/core/server.js

@@ -9,8 +9,9 @@ import { EDITION } from '../edition.js';
 import { VERSION } from '../version.js';
 import { Session } from './session.js';
 import { SessionLog, classifyError } from '../utils/session-log.js';
-import { loadSettings, applyTelemetryEnvOverrides } from './settings.js';
+import { loadSettings, applyTelemetryEnvOverrides, applyUpdateCheckEnvOverride, } from './settings.js';
 import { TelemetryClient } from '../telemetry/client.js';
+import { checkForUpdate, shouldCheckForUpdate } from '../update/check.js';
 import { join, dirname } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { GoSnippetClient, resolveProBinaryPath, coreBinaryName } from '../api/snippet-client.js';
@@ -49,6 +50,7 @@ export class EditmameiServer {
     kernel;
     proModule = null;
     psVersion = null;
+    updateInfo = null;
     snippetClient = new GoSnippetClient();
     constructor() {
         this.logger = new Logger('EditmameiServer');
@@ -56,13 +58,18 @@ export class EditmameiServer {
         this.sessionLog = new SessionLog(this.session.getSessionId());
         this.logger.info(`Session ${this.session.getSessionId()} → ${this.sessionLog.path}`);
         const { settings, created } = loadSettings();
-        const effectiveSettings = applyTelemetryEnvOverrides(settings);
+        const effectiveSettings = applyUpdateCheckEnvOverride(applyTelemetryEnvOverrides(settings));
         this.telemetry = new TelemetryClient({
             settings: effectiveSettings,
             getPsVersion: () => this.psVersion,
         });
         if (created)
             this.logger.info(FIRST_RUN_DISCLOSURE);
+        if (shouldCheckForUpdate(effectiveSettings.update_check)) {
+            void checkForUpdate().then((info) => {
+                this.updateInfo = info;
+            });
+        }
         warnLogScriptOnErrorOnce(this.logger);
         this.toolRegistry = new ToolRegistry({
             onCall: (entry) => {
@@ -124,6 +131,16 @@ export class EditmameiServer {
                             items: { type: 'string' },
                             description: 'List of optional discovery signals that could not be gathered (e.g. "pingState" if the in-PS state snippet failed, "templates" if ~/.editmamei/templates was unreadable). Empty when all signals were collected cleanly. Returned defaults for any degraded field cannot be trusted as ground truth.',
                         },
+                        update_available: {
+                            type: ['object', 'null'],
+                            description: 'Set when a newer Editmamei version is published, else null. When present, TELL THE USER: relay current → latest and how_to_update verbatim. { current, latest, channel (npm/mcpb/dev), how_to_update }. Anonymous npm-registry check at boot; opt out with `editmamei config set update_check false`.',
+                            properties: {
+                                current: { type: 'string' },
+                                latest: { type: 'string' },
+                                channel: { type: 'string' },
+                                how_to_update: { type: 'string' },
+                            },
+                        },
                     },
                 },
                 annotations: {
@@ -286,8 +303,10 @@ export class EditmameiServer {
         const isConnected = await connection.ping();
         if (!isConnected) {
             return {
-                content: [{ type: 'text', text: 'Failed to connect to Photoshop' }],
-                structuredContent: { connected: false },
+                content: [
+                    { type: 'text', text: 'Failed to connect to Photoshop' + this.updateNote() },
+                ],
+                structuredContent: { connected: false, update_available: this.updateInfo },
             };
         }
         let version = 'Unknown';
@@ -336,7 +355,8 @@ export class EditmameiServer {
                     text: `Connected to Photoshop (v${version}). ` +
                         `${actionSetsCount} custom action set(s), ${userTemplates} saved template(s), ` +
                         `${openDocuments.length} open document(s)${openDocuments.length ? ': ' + openDocuments.join(', ') : ''}` +
-                        `${degradedNote}.`,
+                        `${degradedNote}.` +
+                        this.updateNote(),
                 },
             ],
             structuredContent: {
@@ -346,14 +366,21 @@ export class EditmameiServer {
                 user_templates: userTemplates,
                 open_documents: openDocuments,
                 degraded,
+                update_available: this.updateInfo,
             },
         };
     }
+    updateNote() {
+        const u = this.updateInfo;
+        if (!u)
+            return '';
+        return ` Update available: v${u.current} → v${u.latest}. ${u.how_to_update}`;
+    }
     async start() {
-        await this.session.initialize();
         await this.loadModules();
         const transport = new StdioServerTransport();
         await this.server.connect(transport);
+        void this.session.initialize().catch(() => undefined);
         this.telemetry.start();
         void this.telemetry.flushOutboxOnStartup();
         this.server.onclose = () => {

package/dist/core/settings.js

@@ -20,6 +20,7 @@ function defaults(installId) {
         telemetry: { usage: true, diagnostics: false, install_id: installId },
         privacy: { send_previews_to_llm: true },
         photoshop_path: null,
+        update_check: true,
     };
 }
 function coerce(raw, installId) {
@@ -43,6 +44,7 @@ function coerce(raw, installId) {
                 : base.privacy.send_previews_to_llm,
         },
         photoshop_path: typeof r.photoshop_path === 'string' ? r.photoshop_path : null,
+        update_check: typeof r.update_check === 'boolean' ? r.update_check : base.update_check,
     };
 }
 export function loadSettings(opts = {}) {
@@ -102,6 +104,12 @@ export function applyTelemetryEnvOverrides(settings, env = process.env) {
         },
     };
 }
+export function applyUpdateCheckEnvOverride(settings, env = process.env) {
+    const v = parseBoolEnv(env.EDITMAMEI_UPDATE_CHECK);
+    if (v === undefined)
+        return settings;
+    return { ...settings, update_check: v };
+}
 export function saveSettings(settings, opts = {}) {
     const path = settingsPath(opts);
     const dir = dirname(path);

package/dist/core/tool-groups.js

@@ -2,7 +2,7 @@ export const GROUPS = {
     core: {
         id: 'core',
         label: 'Core',
-        purpose: 'Session liveness, orientation, and undo/redo — always available.',
+        purpose: 'Session liveness, orientation, undo/redo, and problem reporting — always available.',
     },
     inspect: {
         id: 'inspect',
@@ -86,6 +86,7 @@ export const TOOL_GROUPS = {
     photoshop_undo: 'core',
     photoshop_redo: 'core',
     photoshop_list_capabilities: 'core',
+    photoshop_report_problem: 'core',
     photoshop_inspect: 'inspect',
     photoshop_get_preview: 'inspect',
     photoshop_get_histogram: 'verify',

package/dist/core/tool-tiers.js

@@ -1,6 +1,7 @@
 export const TOOL_TIERS = {
     photoshop_ping: 'community',
     photoshop_list_capabilities: 'community',
+    photoshop_report_problem: 'community',
     photoshop_list_actions: 'pro',
     photoshop_play_action: 'pro',
     photoshop_execute_script: 'pro',

package/dist/diagnostics/collect.js

@@ -0,0 +1,169 @@
+import { homedir, release as osRelease, arch as osArch, platform as osPlatform } from 'node:os';
+import { readFile, readdir, writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { VERSION } from '../version.js';
+import { EDITION } from '../edition.js';
+import { loadSettings, settingsDir } from '../core/settings.js';
+import { sanitizeMessage } from '../telemetry/sanitize.js';
+import { sharedLogBuffer } from '../utils/log-buffer.js';
+import { readSessionLog, listRecentSessionIds } from '../utils/session-log-reader.js';
+import { classifyError, generateSessionId, } from '../utils/session-log.js';
+import { detectDownloadsDir } from '../cli/downloads-dir.js';
+export const DIAGNOSTIC_BUNDLE_SCHEMA = 1;
+export const ISSUES_URL = 'https://github.com/editmamei/editmamei-wiki/issues';
+const MAX_LOG_LINES = 1000;
+const MAX_DESKTOP_LOG_LINES = 400;
+const MAX_RECENT_SESSIONS = 3;
+const MAX_CALLS_PER_SESSION = 500;
+const MAX_NOTE_LEN = 1000;
+const MAX_LINE_LEN = 4000;
+const MAX_DESKTOP_LINE_LEN = 1000;
+function mcpClientLabel(meta) {
+    if (!meta?.mcp_client)
+        return null;
+    return `${meta.mcp_client.name} ${meta.mcp_client.version}`;
+}
+export async function collectDiagnostics(opts = {}) {
+    const logBuffer = opts.logBuffer ?? sharedLogBuffer;
+    const emHome = opts.homeDir ?? settingsDir();
+    const { settings } = loadSettings(opts.homeDir ? { dir: opts.homeDir } : {});
+    const server_log = logBuffer
+        .snapshot()
+        .slice(-MAX_LOG_LINES)
+        .map((line) => sanitizeMessage(line, MAX_LINE_LEN));
+    const sessionsDir = join(emHome, 'sessions');
+    const recentIds = await listRecentSessionIds(MAX_RECENT_SESSIONS, { dir: sessionsDir });
+    const recent_sessions = [];
+    let psVersion = opts.psVersion ?? null;
+    let mcpClient = null;
+    for (const id of recentIds) {
+        const entries = await readSessionLog(id, { dir: sessionsDir });
+        const meta = [...entries].reverse().find((e) => e.type === 'meta');
+        const calls = entries.filter((e) => e.type === 'call');
+        const reduced = calls.slice(-MAX_CALLS_PER_SESSION).map((c) => ({
+            seq: c.seq,
+            ts: c.ts,
+            tool: c.tool,
+            success: c.success,
+            duration_ms: c.duration_ms,
+            error_class: c.error_class ?? (c.success ? null : classifyError(c.error)),
+        }));
+        if (meta) {
+            if (!psVersion && meta.ps_version)
+                psVersion = meta.ps_version;
+            if (!mcpClient)
+                mcpClient = mcpClientLabel(meta);
+        }
+        recent_sessions.push({
+            session_id: id,
+            editmamei_version: meta?.editmamei_version ?? null,
+            ps_version: meta?.ps_version ?? null,
+            mcp_client: mcpClientLabel(meta),
+            call_count: calls.length,
+            calls: reduced,
+        });
+    }
+    const desktop = await readDesktopLogTail({
+        env: opts.env,
+        overrideDir: opts.desktopLogDir,
+    });
+    return {
+        schema: DIAGNOSTIC_BUNDLE_SCHEMA,
+        report_id: generateSessionId(opts.now),
+        editmamei_version: VERSION,
+        edition: EDITION,
+        platform: osPlatform(),
+        os_release: osRelease(),
+        arch: osArch(),
+        node_version: process.version,
+        install_id: settings.telemetry.install_id,
+        ps_version: psVersion,
+        mcp_client: mcpClient,
+        settings: {
+            telemetry_usage: settings.telemetry.usage,
+            telemetry_diagnostics: settings.telemetry.diagnostics,
+            update_check: settings.update_check,
+            send_previews_to_llm: settings.privacy.send_previews_to_llm,
+        },
+        note: opts.note ? sanitizeMessage(opts.note, MAX_NOTE_LEN) : null,
+        server_log,
+        desktop_log: desktop.lines,
+        desktop_log_source: desktop.source,
+        recent_sessions,
+    };
+}
+export async function writeDiagnosticBundle(bundle, opts = {}) {
+    const dest = opts.downloadsDir ?? detectDownloadsDir(opts.env ?? process.env).path;
+    await mkdir(dest, { recursive: true });
+    const path = join(dest, `editmamei-diagnostics-${bundle.report_id}.json`);
+    const json = JSON.stringify(bundle, null, 2);
+    await writeFile(path, json, { encoding: 'utf8', mode: 0o600 });
+    return { path, bytes: Buffer.byteLength(json, 'utf8') };
+}
+export function defaultDesktopLogDir(env = process.env) {
+    if (process.platform === 'darwin')
+        return join(homedir(), 'Library', 'Logs', 'Claude');
+    if (process.platform === 'win32') {
+        const appData = env.APPDATA;
+        return appData
+            ? join(appData, 'Claude', 'logs')
+            : join(homedir(), 'AppData', 'Roaming', 'Claude', 'logs');
+    }
+    return null;
+}
+const BASE64_RUN = /[A-Za-z0-9+/]{200,}={0,2}/g;
+const JSONRPC_FRAME = /^(.*\bMessage (?:from|to) (?:client|server):\s*)(\{.*)$/;
+const PAYLOAD_OBJECT = /("(?:arguments|params|result|input)"\s*:\s*)([{[][\s\S]*)$/;
+export function sanitizeDesktopLogLine(line) {
+    const frame = JSONRPC_FRAME.exec(line);
+    if (frame) {
+        const prefix = sanitizeMessage(frame[1], MAX_LINE_LEN).replace(/\s+$/, '');
+        const body = frame[2];
+        const method = /"method"\s*:\s*"([^"]+)"/.exec(body)?.[1];
+        const id = /"id"\s*:\s*("?[\w.-]+"?)/.exec(body)?.[1];
+        const kind = method
+            ? `method=${method}`
+            : /"result"/.test(body)
+                ? 'result'
+                : /"error"/.test(body)
+                    ? 'error'
+                    : 'frame';
+        return `${prefix} [${kind}${id ? ` id=${id}` : ''}, payload redacted, ${body.length} bytes]`;
+    }
+    let out = sanitizeMessage(line, MAX_LINE_LEN);
+    out = out.replace(PAYLOAD_OBJECT, '$1<redacted>');
+    out = out.replace(BASE64_RUN, '…[binary redacted]');
+    if (out.length > MAX_DESKTOP_LINE_LEN)
+        out = out.slice(0, MAX_DESKTOP_LINE_LEN) + '…[truncated]';
+    return out;
+}
+async function readDesktopLogTail(opts) {
+    const dir = opts.overrideDir ?? defaultDesktopLogDir(opts.env ?? process.env);
+    if (!dir)
+        return { lines: [], source: null };
+    let names;
+    try {
+        names = await readdir(dir);
+    }
+    catch {
+        return { lines: [], source: null };
+    }
+    const logs = names.filter((f) => f.toLowerCase().endsWith('.log'));
+    if (logs.length === 0)
+        return { lines: [], source: null };
+    const pick = logs.find((f) => /editmamei/i.test(f)) ??
+        logs.find((f) => f.toLowerCase() === 'mcp.log') ??
+        logs[0];
+    try {
+        const raw = await readFile(join(dir, pick), 'utf8');
+        const tail = raw
+            .split(/\r?\n/)
+            .filter((l) => l.length > 0)
+            .slice(-MAX_DESKTOP_LOG_LINES)
+            .map(sanitizeDesktopLogLine);
+        return { lines: tail, source: pick };
+    }
+    catch {
+        return { lines: [], source: null };
+    }
+}

package/dist/install-channel.js

@@ -0,0 +1,8 @@
+import { EDITION } from './edition.js';
+export function resolveInstallChannel(env = process.env, edition = EDITION) {
+    if (edition === 'dev')
+        return 'dev';
+    if (env.EDITMAMEI_INSTALL_CHANNEL === 'mcpb')
+        return 'mcpb';
+    return 'npm';
+}

package/dist/modules/ce/index.js

@@ -17,6 +17,7 @@ import { createLayerOrderingTools } from '../../tools/layer-ordering-tools.js';
 import { createPreviewTools } from '../../tools/preview-tools.js';
 import { createInspectTools } from '../../tools/inspect-tools.js';
 import { createOverviewTools } from '../../tools/overview-tools.js';
+import { createDiagnosticsTools } from '../../tools/diagnostics-tools.js';
 import { createRetouchTools } from '../../tools/retouch-tools.js';
 import { createBrushTools } from '../../tools/brush-tools.js';
 import { createTransformCanvasTools } from '../../tools/transform-canvas-tools.js';
@@ -45,6 +46,7 @@ const ceFactories = [
     createPreviewTools,
     createInspectTools,
     createOverviewTools,
+    createDiagnosticsTools,
     createRetouchTools,
     createBrushTools,
     createTransformCanvasTools,

package/dist/tools/diagnostics-tools.js

@@ -0,0 +1,66 @@
+import { collectDiagnostics, writeDiagnosticBundle, ISSUES_URL } from '../diagnostics/collect.js';
+const reportSchema = {
+    type: 'object',
+    properties: {
+        note: {
+            type: 'string',
+            description: 'Optional short description of the problem (what went wrong, what you were doing). Embedded verbatim after sanitization. No file contents or paths needed.',
+        },
+    },
+};
+export function createDiagnosticsTools(_connection, _snippetClient, deps = {}) {
+    const collect = deps.collect ?? collectDiagnostics;
+    const writeBundle = deps.write ?? writeDiagnosticBundle;
+    return [
+        {
+            tool: {
+                name: 'photoshop_report_problem',
+                description: "Collect an ANONYMIZED diagnostic bundle and write it to the user's Downloads folder so they can attach it to a bug report — use when Editmamei misbehaves (won't connect, a tool keeps failing, unexpected results). The bundle holds recent server logs, system info (Editmamei/OS/Photoshop versions), and a content-free summary of recent tool calls (name, success, duration, error class). It contains NO image content, NO tool arguments, and file paths reduced to basenames. Does not touch Photoshop; writes one JSON file. After calling, tell the user the file path and that they can attach it to a new issue at " +
+                    ISSUES_URL +
+                    '.',
+                inputSchema: reportSchema,
+                outputSchema: {
+                    type: 'object',
+                    properties: {
+                        path: { type: 'string' },
+                        bytes: { type: 'number' },
+                        server_log_lines: { type: 'number' },
+                        recent_session_count: { type: 'number' },
+                        desktop_log_included: { type: 'boolean' },
+                        issues_url: { type: 'string' },
+                    },
+                },
+                annotations: {
+                    title: 'Report a problem',
+                    readOnlyHint: false,
+                    destructiveHint: false,
+                    idempotentHint: false,
+                    openWorldHint: true,
+                },
+            },
+            handler: async (args) => {
+                const note = typeof args.note === 'string' ? args.note : undefined;
+                const bundle = await collect({ note });
+                const { path, bytes } = await writeBundle(bundle);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Wrote an anonymized diagnostic bundle to:\n  ${path}\n\n` +
+                                `It contains recent logs + system info — no images, no full file paths, no tool arguments. ` +
+                                `Attach this file to a new issue at ${ISSUES_URL} so the maintainers can debug.`,
+                        },
+                    ],
+                    structuredContent: {
+                        path,
+                        bytes,
+                        server_log_lines: bundle.server_log.length,
+                        recent_session_count: bundle.recent_sessions.length,
+                        desktop_log_included: bundle.desktop_log.length > 0,
+                        issues_url: ISSUES_URL,
+                    },
+                };
+            },
+        },
+    ];
+}

package/dist/update/check.js

@@ -0,0 +1,77 @@
+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 RELEASES_URL = 'https://github.com/editmamei/editmamei-wiki/releases/latest';
+export function resolveUpdateCheckUrl(env = process.env) {
+    const override = env.EDITMAMEI_UPDATE_CHECK_URL;
+    return override && override.length > 0 ? override : DEFAULT_DIST_TAGS_URL;
+}
+export function httpFetchLatest() {
+    return async (url, timeoutMs) => {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const res = await fetch(url, {
+                headers: { accept: 'application/json' },
+                signal: controller.signal,
+            });
+            if (!res.ok)
+                return null;
+            const data = (await res.json());
+            return typeof data.latest === 'string' ? data.latest : null;
+        }
+        catch {
+            return null;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    };
+}
+function parseSemver(v) {
+    const m = /^(\d+)\.(\d+)\.(\d+)$/.exec(v.trim());
+    return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;
+}
+export function isNewer(latest, current) {
+    const a = parseSemver(latest);
+    const b = parseSemver(current);
+    if (!a || !b)
+        return false;
+    for (let i = 0; i < 3; i++) {
+        if (a[i] !== b[i])
+            return a[i] > b[i];
+    }
+    return false;
+}
+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 'dev':
+            return `You're on a local dev build — pull the latest source and rebuild.`;
+        case 'npm':
+        default:
+            return `Run: npm install -g editmamei@latest (then restart your MCP client).`;
+    }
+}
+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 = {}) {
+    try {
+        const env = opts.env ?? process.env;
+        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))
+            return null;
+        if (!isNewer(latest, current))
+            return null;
+        return { current, latest, channel, how_to_update: updateMessage(channel, latest) };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/utils/log-buffer.js

@@ -0,0 +1,41 @@
+const DEFAULT_CAPACITY = 1000;
+export class LogRingBuffer {
+    buf;
+    capacity;
+    next = 0;
+    full = false;
+    constructor(capacity = DEFAULT_CAPACITY) {
+        this.capacity = Math.max(1, Math.floor(capacity));
+        this.buf = new Array(this.capacity);
+    }
+    push(line) {
+        this.buf[this.next] = line;
+        this.next = (this.next + 1) % this.capacity;
+        if (this.next === 0)
+            this.full = true;
+    }
+    snapshot() {
+        if (!this.full)
+            return this.buf.slice(0, this.next);
+        return [
+            ...this.buf.slice(this.next),
+            ...this.buf.slice(0, this.next),
+        ];
+    }
+    get size() {
+        return this.full ? this.capacity : this.next;
+    }
+    clear() {
+        this.buf.fill(undefined);
+        this.next = 0;
+        this.full = false;
+    }
+}
+export const sharedLogBuffer = new LogRingBuffer();
+export function recordLogLine(line) {
+    try {
+        sharedLogBuffer.push(line);
+    }
+    catch {
+    }
+}

package/dist/utils/logger.js

@@ -1,3 +1,4 @@
+import { recordLogLine } from './log-buffer.js';
 export var LogLevel;
 (function (LogLevel) {
     LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
@@ -58,12 +59,21 @@ export function parseLogLevel(raw, fallback) {
             return fallback;
     }
 }
+function isVerboseEnabled(v) {
+    if (v === undefined)
+        return false;
+    const s = v.trim().toLowerCase();
+    return s === 'true' || s === '1';
+}
 export class Logger {
     context;
     logLevel;
     constructor(context, logLevel = LogLevel.INFO) {
         this.context = context;
-        this.logLevel = parseLogLevel(process.env.LOG_LEVEL, logLevel);
+        const fallback = isVerboseEnabled(process.env.EDITMAMEI_VERBOSE_LOGGING)
+            ? LogLevel.DEBUG
+            : logLevel;
+        this.logLevel = parseLogLevel(process.env.LOG_LEVEL, fallback);
     }
     log(level, message, ...args) {
         if (level < this.logLevel)
@@ -74,6 +84,7 @@ export class Logger {
         const formattedArgs = args.map(serializeLogArg).join(' ');
         const logMessage = `${prefix} ${message} ${formattedArgs}`.trim();
         process.stderr.write(logMessage + '\n');
+        recordLogLine(logMessage);
     }
     debug(message, ...args) {
         this.log(LogLevel.DEBUG, message, ...args);

package/dist/utils/session-log-reader.js

@@ -1,7 +1,8 @@
-import { readFile } from 'node:fs/promises';
+import { readFile, readdir, stat } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { Logger } from './logger.js';
+const SESSION_FILE_SUFFIX = '.ndjson';
 const logger = new Logger('SessionLogReader');
 export async function readSessionLog(sessionId, opts = {}) {
     const dir = opts.dir ?? join(homedir(), '.editmamei', 'sessions');
@@ -36,3 +37,28 @@ export async function readSessionLog(sessionId, opts = {}) {
     }
     return out;
 }
+export async function listRecentSessionIds(limit, opts = {}) {
+    const dir = opts.dir ?? join(homedir(), '.editmamei', 'sessions');
+    let names;
+    try {
+        names = await readdir(dir);
+    }
+    catch {
+        return [];
+    }
+    const files = names.filter((f) => f.endsWith(SESSION_FILE_SUFFIX));
+    const withMtime = await Promise.all(files.map(async (f) => {
+        try {
+            const s = await stat(join(dir, f));
+            return { id: f.slice(0, -SESSION_FILE_SUFFIX.length), mtime: s.mtimeMs };
+        }
+        catch {
+            return null;
+        }
+    }));
+    return withMtime
+        .filter((x) => x !== null)
+        .sort((a, b) => b.mtime - a.mtime)
+        .slice(0, Math.max(0, limit))
+        .map((x) => x.id);
+}

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.18.0';
+export const VERSION = '0.20.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "editmamei",
-  "version": "0.18.0",
+  "version": "0.20.0",
   "description": "Editmamei — Unlock Photoshop with natural-language photo editing (Community Edition)",
   "main": "dist/index.js",
   "type": "module",