editmamei 0.19.0 → 0.22.0

package/dist/core/tool-tiers.js

@@ -1,85 +1,95 @@
 export const TOOL_TIERS = {
-    photoshop_ping: 'community',
-    photoshop_list_capabilities: 'community',
-    photoshop_list_actions: 'pro',
-    photoshop_play_action: 'pro',
-    photoshop_execute_script: 'pro',
-    photoshop_add_adjustment_layer: 'community',
-    photoshop_apply_adjustment: 'community',
-    photoshop_create_document: 'community',
-    photoshop_close_document: 'community',
-    photoshop_open_document: 'community',
-    photoshop_save_psd: 'community',
-    photoshop_export: 'community',
-    photoshop_apply_filter: 'community',
-    photoshop_create_group: 'community',
-    photoshop_move_layer_to_group: 'community',
-    photoshop_set_group_blend_mode: 'community',
-    photoshop_ungroup: 'community',
-    photoshop_delete_group: 'community',
-    photoshop_create_clipping_mask: 'community',
-    photoshop_release_clipping_mask: 'dev',
-    photoshop_undo: 'community',
-    photoshop_redo: 'community',
-    photoshop_place_image: 'community',
-    photoshop_resize_image: 'community',
-    photoshop_crop_document: 'community',
-    photoshop_convert_image_mode: 'community',
-    photoshop_move_layer_to_position: 'community',
-    photoshop_convert_to_smart_object: 'community',
-    photoshop_rasterize_layer: 'community',
-    photoshop_set_layer: 'community',
-    photoshop_duplicate_layer: 'community',
-    photoshop_layer_via_copy: 'community',
-    photoshop_merge: 'community',
-    photoshop_bake_layer: 'community',
-    photoshop_add_layer_style: 'community',
-    photoshop_create_layer: 'community',
-    photoshop_delete_layer: 'community',
-    photoshop_create_text_layer: 'community',
-    photoshop_fill_layer: 'community',
-    photoshop_add_fill_layer: 'community',
-    photoshop_select_layer: 'community',
-    photoshop_transform_layer: 'community',
-    photoshop_warp_layer: 'pro',
-    photoshop_warp_layer_mesh: 'pro',
-    photoshop_transform_canvas: 'community',
-    photoshop_guides: 'community',
-    photoshop_inspect: 'community',
-    photoshop_overview: 'community',
-    photoshop_get_preview: 'community',
-    photoshop_get_layer_bounds_diff: 'community',
-    photoshop_compare_regions: 'community',
-    photoshop_get_histogram: 'community',
-    photoshop_retouch: 'community',
-    photoshop_apply_brush_stroke: 'dev',
-    photoshop_detect: 'community',
-    photoshop_object: 'dev',
-    photoshop_portrait_touchup: 'dev',
-    photoshop_text_on_object: 'dev',
-    photoshop_detect_landmarks: 'pro',
-    photoshop_select_face_feature: 'pro',
-    photoshop_stroke_face_contour: 'dev',
-    photoshop_scene: 'community',
-    photoshop_select_by_reference: 'community',
-    photoshop_select: 'community',
-    photoshop_select_subject: 'pro',
-    photoshop_select_sky: 'pro',
-    photoshop_select_subject_instance: 'pro',
-    photoshop_modify_selection: 'community',
-    photoshop_get_selection_preview: 'community',
-    photoshop_selection_channel: 'community',
-    photoshop_layer_mask: 'community',
-    photoshop_path: 'community',
-    photoshop_vector_mask: 'community',
-    photoshop_template_create_evidence: 'pro',
-    photoshop_template_save: 'pro',
-    photoshop_template_list: 'pro',
-    photoshop_template_apply: 'pro',
-    photoshop_template_verify: 'pro',
-    photoshop_template_recall: 'pro',
-    photoshop_template_delete: 'pro',
-    photoshop_set_text: 'community',
+    ps_ping: 'community',
+    ps_list_capabilities: 'community',
+    ps_report_problem: 'community',
+    ps_list_actions: 'pro',
+    ps_play_action: 'pro',
+    ps_execute_script: 'pro',
+    ps_add_adjustment_layer: 'community',
+    ps_apply_adjustment: 'community',
+    ps_create_document: 'community',
+    ps_close_document: 'community',
+    ps_open_document: 'community',
+    ps_save_psd: 'community',
+    ps_export: 'community',
+    ps_apply_filter: 'community',
+    ps_create_group: 'community',
+    ps_move_layer_to_group: 'community',
+    ps_set_group_blend_mode: 'community',
+    ps_ungroup: 'community',
+    ps_delete_group: 'community',
+    ps_create_clipping_mask: 'community',
+    ps_release_clipping_mask: 'dev',
+    ps_undo: 'community',
+    ps_redo: 'community',
+    ps_place_image: 'community',
+    ps_resize_image: 'community',
+    ps_crop_document: 'community',
+    ps_convert_image_mode: 'community',
+    ps_move_layer_to_position: 'community',
+    ps_convert_to_smart_object: 'community',
+    ps_rasterize_layer: 'community',
+    ps_set_layer: 'community',
+    ps_duplicate_layer: 'community',
+    ps_copy_to_new_layer: 'community',
+    ps_merge: 'community',
+    ps_bake_layer: 'community',
+    ps_add_layer_style: 'community',
+    ps_create_layer: 'community',
+    ps_delete_layer: 'community',
+    ps_create_text_layer: 'community',
+    ps_fill_layer: 'community',
+    ps_add_fill_layer: 'community',
+    ps_select_layer: 'community',
+    ps_transform_layer: 'community',
+    ps_warp_layer: 'pro',
+    ps_warp_layer_mesh: 'pro',
+    ps_warp_layer_along: 'pro',
+    ps_warp_layer_region: 'pro',
+    ps_warp_layer_to: 'pro',
+    ps_apply_camera_raw: 'pro',
+    ps_transform_canvas: 'community',
+    ps_guides: 'community',
+    ps_inspect: 'community',
+    ps_overview: 'community',
+    ps_get_preview: 'community',
+    ps_get_layer_bounds_diff: 'community',
+    ps_compare_regions: 'community',
+    ps_get_histogram: 'community',
+    ps_retouch: 'community',
+    ps_apply_brush_stroke: 'dev',
+    ps_detect: 'community',
+    ps_edit_object: 'pro',
+    ps_portrait_touchup: 'dev',
+    ps_add_text_to_object: 'pro',
+    ps_detect_landmarks: 'pro',
+    ps_select_face_feature: 'pro',
+    ps_stroke_face_contour: 'dev',
+    ps_read_scene: 'community',
+    ps_select_by_reference: 'community',
+    ps_select: 'community',
+    ps_select_subject: 'community',
+    ps_select_sky: 'community',
+    ps_select_subject_instance: 'pro',
+    ps_select_object: 'pro',
+    ps_modify_selection: 'community',
+    ps_get_selection_preview: 'community',
+    ps_selection_channel: 'community',
+    ps_layer_mask: 'community',
+    ps_path: 'community',
+    ps_vector_mask: 'community',
+    ps_apply_image: 'community',
+    ps_calculations: 'community',
+    ps_shape: 'community',
+    ps_resolve_placement: 'pro',
+    ps_template_create_evidence: 'pro',
+    ps_template_save: 'pro',
+    ps_template_list: 'pro',
+    ps_template_apply: 'pro',
+    ps_template_verify: 'pro',
+    ps_template_recall: 'pro',
+    ps_template_delete: 'pro',
+    ps_set_text: 'community',
 };
 export function tierOf(toolName) {
     const tier = TOOL_TIERS[toolName];

package/dist/detection/landmark-detection-client.js

@@ -1,6 +1,7 @@
 import { decodeJpeg as realDecodeJpeg } from './runtime.js';
 import { detectLandmarks as realDetectLandmarks, } from './landmark-detector.js';
 import { OnnxDetectionClient, } from './detection-client.js';
+import { correctMeshEyes } from './mesh-eye-correction.js';
 const LANDMARK_BACKEND = 'facemesh-468';
 export class OnnxLandmarkDetectionClient {
     base;
@@ -20,11 +21,18 @@ export class OnnxLandmarkDetectionClient {
         const img = this.decodeJpeg(imagePath);
         const minScore = this.opts.minScore ?? 0.5;
         const lmOpts = { margin: this.opts.margin };
+        const correctEyes = this.opts.correctEyes ?? true;
         for (const face of result.faces) {
             try {
                 const mesh = await this.detectLandmarks(img, face.bbox, lmOpts);
                 if (mesh.score >= minScore) {
                     face.features = { points: mesh.points, score: mesh.score, backend: LANDMARK_BACKEND };
+                    if (correctEyes) {
+                        const c = correctMeshEyes(img, face.features.points);
+                        face.features.points = c.points;
+                        if (c.correction)
+                            face.features.eyeCorrection = c.correction;
+                    }
                 }
             }
             catch {

package/dist/detection/mesh-eye-correction.js

@@ -0,0 +1,126 @@
+import { LANDMARK_GROUPS, LANDMARK_COUNT } from './landmark-spec.js';
+const EYE_RIGID_GROUPS = ['leftEye', 'rightEye', 'leftEyebrow', 'rightEyebrow', 'nose'];
+const EYE_RIGID_INDICES = new Set();
+for (const g of EYE_RIGID_GROUPS)
+    for (const i of LANDMARK_GROUPS[g])
+        EYE_RIGID_INDICES.add(i);
+const centroid = (pts) => ({
+    x: pts.reduce((s, p) => s + p.x, 0) / pts.length,
+    y: pts.reduce((s, p) => s + p.y, 0) / pts.length,
+});
+const bbox = (pts) => ({
+    x0: Math.min(...pts.map((p) => p.x)),
+    y0: Math.min(...pts.map((p) => p.y)),
+    x1: Math.max(...pts.map((p) => p.x)),
+    y1: Math.max(...pts.map((p) => p.y)),
+});
+const dist = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
+function makeCtx(img) {
+    const { width: W, height: H, data } = img;
+    const luma = (x, y) => {
+        const i = (y * W + x) * 4;
+        return 0.299 * data[i] + 0.587 * data[i + 1] + 0.114 * data[i + 2];
+    };
+    const clamp = (v, lo, hi) => Math.min(Math.max(v, lo), hi);
+    const blur = (x, y, r) => {
+        let s = 0, n = 0;
+        for (let dy = -r; dy <= r; dy++)
+            for (let dx = -r; dx <= r; dx++) {
+                s += luma(clamp(x + dx, 0, W - 1), clamp(y + dy, 0, H - 1));
+                n++;
+            }
+        return s / n;
+    };
+    return { W, H, luma, clamp, blur };
+}
+function findEyeCenter(ctx, center, ring) {
+    const { W, H, luma, clamp, blur } = ctx;
+    const rw = ring.x1 - ring.x0, rh = ring.y1 - ring.y0;
+    const x0 = clamp(Math.round(center.x - 0.55 * rw), 0, W - 1);
+    const x1 = clamp(Math.round(center.x + 0.55 * rw), 0, W - 1);
+    const y0 = clamp(Math.round(center.y - 0.5 * rh), 0, H - 1);
+    const y1 = clamp(Math.round(center.y + 2.0 * rh), 0, H - 1);
+    const ww = x1 - x0 + 1, wh = y1 - y0 + 1;
+    if (ww < 5 || wh < 5)
+        return { x: center.x, y: center.y, atEdge: false };
+    const L = new Float32Array(ww * wh);
+    for (let y = 0; y < wh; y++)
+        for (let x = 0; x < ww; x++)
+            L[y * ww + x] = luma(x0 + x, y0 + y);
+    const edges = [];
+    const gg = [];
+    let magSum = 0;
+    for (let y = 1; y < wh - 1; y++)
+        for (let x = 1; x < ww - 1; x++) {
+            const gx = (L[y * ww + x + 1] - L[y * ww + x - 1]) / 2;
+            const gy = (L[(y + 1) * ww + x] - L[(y - 1) * ww + x]) / 2;
+            const m = Math.hypot(gx, gy);
+            gg.push({ m, x, y, gx, gy });
+            magSum += m;
+        }
+    const mean = magSum / (gg.length || 1);
+    let v = 0;
+    for (const g of gg)
+        v += (g.m - mean) ** 2;
+    const std = Math.sqrt(v / (gg.length || 1));
+    const thr = mean + 0.3 * std;
+    for (const g of gg)
+        if (g.m > thr)
+            edges.push({ x: g.x, y: g.y, gx: g.gx / g.m, gy: g.gy / g.m });
+    let best = -Infinity, bx = Math.round(center.x - x0), by = Math.round(center.y - y0);
+    for (let cy = 2; cy < wh - 2; cy += 2)
+        for (let cx = 2; cx < ww - 2; cx += 2) {
+            let s = 0;
+            for (const e of edges) {
+                const dx = e.x - cx, dy = e.y - cy, l = Math.hypot(dx, dy);
+                if (l < 3)
+                    continue;
+                const dot = (dx / l) * e.gx + (dy / l) * e.gy;
+                if (dot > 0)
+                    s += dot * dot;
+            }
+            s *= 255 - blur(x0 + cx, y0 + cy, 3);
+            if (s > best) {
+                best = s;
+                bx = cx;
+                by = cy;
+            }
+        }
+    const atEdge = bx <= 3 || bx >= ww - 4 || by >= wh - 4;
+    return { x: x0 + bx, y: y0 + by, atEdge };
+}
+function similarity(m1, m2, t1, t2) {
+    const dmx = m2.x - m1.x, dmy = m2.y - m1.y, dtx = t2.x - t1.x, dty = t2.y - t1.y;
+    const s = Math.hypot(dtx, dty) / (Math.hypot(dmx, dmy) || 1);
+    const th = Math.atan2(dty, dtx) - Math.atan2(dmy, dmx);
+    const c = Math.cos(th) * s, sn = Math.sin(th) * s;
+    return (p) => ({
+        x: t1.x + c * (p.x - m1.x) - sn * (p.y - m1.y),
+        y: t1.y + sn * (p.x - m1.x) + c * (p.y - m1.y),
+    });
+}
+export function correctMeshEyes(img, points) {
+    if (!points || points.length < LANDMARK_COUNT)
+        return { points, correction: null };
+    if (!img || !img.data || img.data.length < img.width * img.height * 4) {
+        return { points, correction: null };
+    }
+    const ctx = makeCtx(img);
+    const leftEye = LANDMARK_GROUPS.leftEye.map((i) => points[i]);
+    const rightEye = LANDMARK_GROUPS.rightEye.map((i) => points[i]);
+    const eyeLm = centroid(leftEye), eyeRm = centroid(rightEye);
+    if (dist(eyeLm, eyeRm) < 4)
+        return { points, correction: null };
+    const eyeLc = findEyeCenter(ctx, eyeLm, bbox(leftEye));
+    const eyeRc = findEyeCenter(ctx, eyeRm, bbox(rightEye));
+    const T = similarity(eyeLm, eyeRm, eyeLc, eyeRc);
+    const corrected = points.map((p, i) => (EYE_RIGID_INDICES.has(i) ? { ...T(p), z: p.z } : p));
+    return {
+        points: corrected,
+        correction: {
+            drift_left: Math.round(dist(eyeLc, eyeLm)),
+            drift_right: Math.round(dist(eyeRc, eyeRm)),
+            low_confidence: eyeLc.atEdge || eyeRc.atEdge,
+        },
+    };
+}

package/dist/detection/sam-segmenter.js

@@ -0,0 +1,83 @@
+import { loadModel, resolveModelPath, ort } from './runtime.js';
+const MODEL_ENCODER = 'pro/mobile_sam_encoder.onnx';
+const MODEL_DECODER = 'pro/mobile_sam_decoder.onnx';
+const SAM_INPUT = 1024;
+export function boxToPromptCoords(box, imgW, imgH) {
+    const s = SAM_INPUT / Math.max(imgW, imgH);
+    const [x1, y1, x2, y2] = box;
+    return {
+        coords: Float32Array.from([x1 * s, y1 * s, x2 * s, y2 * s]),
+        labels: Float32Array.from([2, 3]),
+    };
+}
+export function pointsToPromptCoords(fg, bg, imgW, imgH) {
+    const s = SAM_INPUT / Math.max(imgW, imgH);
+    const pts = [...fg, ...bg, { x: 0, y: 0 }];
+    const labels = [...fg.map(() => 1), ...bg.map(() => 0), -1];
+    const coords = new Float32Array(pts.length * 2);
+    pts.forEach((p, i) => {
+        coords[i * 2] = p.x * s;
+        coords[i * 2 + 1] = p.y * s;
+    });
+    return { coords, labels: Float32Array.from(labels) };
+}
+export function toEncoderInput(img) {
+    const { width: w, height: h, data } = img;
+    const out = new Float32Array(h * w * 3);
+    for (let p = 0; p < h * w; p++) {
+        out[p * 3] = data[p * 4];
+        out[p * 3 + 1] = data[p * 4 + 1];
+        out[p * 3 + 2] = data[p * 4 + 2];
+    }
+    return out;
+}
+export function thresholdMask(maskData, n) {
+    const mask = new Uint8Array(n);
+    for (let i = 0; i < n; i++)
+        mask[i] = maskData[i] > 0 ? 1 : 0;
+    return mask;
+}
+export class OnnxSamSegmenter {
+    async encodeImage(img) {
+        const session = await loadModel(resolveModelPath(MODEL_ENCODER));
+        const input = new ort.Tensor('float32', toEncoderInput(img), [img.height, img.width, 3]);
+        const out = await session.run({ input_image: input });
+        return out.image_embeddings;
+    }
+    async runDecoder(embedding, coords, labels, imgW, imgH) {
+        const session = await loadModel(resolveModelPath(MODEL_DECODER));
+        const nPts = labels.length;
+        const out = await session.run({
+            image_embeddings: embedding,
+            point_coords: new ort.Tensor('float32', coords, [1, nPts, 2]),
+            point_labels: new ort.Tensor('float32', labels, [1, nPts]),
+            mask_input: new ort.Tensor('float32', new Float32Array(256 * 256), [1, 1, 256, 256]),
+            has_mask_input: new ort.Tensor('float32', Float32Array.from([0]), [1]),
+            orig_im_size: new ort.Tensor('float32', Float32Array.from([imgH, imgW]), [2]),
+        });
+        const masks = out.masks;
+        const [, , mh, mw] = masks.dims;
+        return {
+            mask: thresholdMask(masks.data, mh * mw),
+            width: mw,
+            height: mh,
+            iou: out.iou_predictions.data[0] ?? 0,
+        };
+    }
+    async segmentBox(embedding, box, imgW, imgH) {
+        const { coords, labels } = boxToPromptCoords(box, imgW, imgH);
+        return this.runDecoder(embedding, coords, labels, imgW, imgH);
+    }
+    async segmentPointsAt(embedding, fg, bg, imgW, imgH) {
+        const { coords, labels } = pointsToPromptCoords(fg, bg, imgW, imgH);
+        return this.runDecoder(embedding, coords, labels, imgW, imgH);
+    }
+    async segment(img, box) {
+        const embedding = await this.encodeImage(img);
+        return this.segmentBox(embedding, box, img.width, img.height);
+    }
+    async segmentPoints(img, fg, bg = []) {
+        const embedding = await this.encodeImage(img);
+        return this.segmentPointsAt(embedding, fg, bg, img.width, img.height);
+    }
+}

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/index.js

@@ -4,6 +4,7 @@ import { pathToFileURL } from 'node:url';
 import { EditmameiServer } from './core/server.js';
 import { routeCli } from './cli/router.js';
 import { maybeActivateFromEnv } from './license/env-activation.js';
+import { refreshIfStale } from './license/entitlement.js';
 import { Logger } from './utils/logger.js';
 const logger = new Logger('Main');
 function installProcessHandlers() {
@@ -37,6 +38,7 @@ async function main() {
     try {
         logger.info('Starting Editmamei...');
         await maybeActivateFromEnv();
+        await refreshIfStale();
         const server = new EditmameiServer();
         await server.start();
         let shuttingDown = false;

package/dist/license/entitlement.js

@@ -2,7 +2,11 @@ import { resolvePolarConfig } from './config.js';
 import { computeDeviceHash } from './device-hash.js';
 import { readLicense, writeLicense, clearLicense, } from './store.js';
 import { PolarLicenseClient, PolarLicenseError } from './polar-client.js';
+import { Logger } from '../utils/logger.js';
+const logger = new Logger('License');
 export const GRACE_MS = 30 * 24 * 60 * 60 * 1000;
+export const REFRESH_AFTER_MS = 7 * 24 * 60 * 60 * 1000;
+export const EXPIRED_REFRESH_TIMEOUT_MS = 5_000;
 export function evaluateEntitlement(rec, now) {
     if (!rec)
         return { entitled: false, reason: 'no-license' };
@@ -59,6 +63,54 @@ export async function activate(key, ops = {}) {
     writeLicense(rec, ops);
     return rec;
 }
+export async function refreshIfStale(ops = {}) {
+    const env = ops.env ?? process.env;
+    if (env.VITEST !== undefined || env.NODE_ENV === 'test')
+        return;
+    const rec = readLicense(ops);
+    if (!rec)
+        return;
+    if (rec.status === 'revoked' || rec.status === 'disabled')
+        return;
+    const now = (ops.now ?? Date.now)();
+    if (rec.expires_at !== null && Date.parse(rec.expires_at) <= now)
+        return;
+    const last = Date.parse(rec.last_validated_at);
+    const age = Number.isFinite(last) ? now - last : Infinity;
+    if (age <= REFRESH_AFTER_MS)
+        return;
+    if (age <= GRACE_MS) {
+        refresh(ops).catch((err) => {
+            logger.warn(`Background license refresh failed (grace covers offline use): ` +
+                `${err instanceof Error ? err.message : String(err)}`);
+        });
+        return;
+    }
+    const timeoutMs = ops.expiredRefreshTimeoutMs ?? EXPIRED_REFRESH_TIMEOUT_MS;
+    const attempt = refresh(ops);
+    attempt.catch(() => { });
+    let timer;
+    try {
+        const winner = await Promise.race([
+            attempt,
+            new Promise((resolve) => {
+                timer = setTimeout(() => resolve('timeout'), timeoutMs);
+                timer.unref?.();
+            }),
+        ]);
+        if (winner === 'timeout') {
+            logger.warn('License re-validation timed out past the grace window — continuing as Community; the next boot retries.');
+        }
+    }
+    catch (err) {
+        logger.warn(`License re-validation failed past the grace window (continuing as Community): ` +
+            `${err instanceof Error ? err.message : String(err)}`);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
 export async function refresh(ops = {}) {
     const rec = readLicense(ops);
     if (!rec)