editmamei 0.19.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/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

@@ -377,10 +377,10 @@ export class EditmameiServer {
         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/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/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/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.19.0';
+export const VERSION = '0.20.0';

package/package.json

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