editmamei 0.22.0 → 0.22.2

package/dist/cli/help.js

@@ -9,6 +9,8 @@ Usage:
   editmamei config           Get/set settings (telemetry, privacy) in ~/.editmamei/settings.json
   editmamei activate <key>   Activate a Pro license on this device
   editmamei deactivate       Free this device's seat (before moving Pro to another machine)
+  editmamei repair           Re-download the Pro module if it wedged after a host update
+                             (fixes it without deleting ~/.editmamei — keeps templates + license)
   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

package/dist/cli/repair.js

@@ -0,0 +1,36 @@
+import { readLicense } from '../license/store.js';
+import { provisionModules } from '../delivery/provision.js';
+export async function runRepair(opts = {}) {
+    const out = opts.stdout ?? ((s) => process.stdout.write(s));
+    const err = opts.stderr ?? ((s) => process.stderr.write(s));
+    const license = readLicense({ dir: opts.dir });
+    if (!license) {
+        err('No Pro license found on this device. Run `editmamei activate <license-key>` first.\n');
+        throw new Error('no license');
+    }
+    out('Repairing the Pro module (re-provisioning from the delivery service)…\n');
+    const prov = await provisionModules(license.key, {
+        force: true,
+        dir: opts.dir,
+        now: opts.now,
+        config: opts.delivery?.config,
+        fetchImpl: opts.delivery?.fetchImpl,
+        signingKeys: opts.delivery?.signingKeys,
+        sleep: opts.delivery?.sleep,
+    });
+    if (prov.notConfigured) {
+        out('  Module delivery is not configured in this build — nothing to repair.\n');
+        return;
+    }
+    for (const m of prov.installed)
+        out(`  Installed ${m.sku} module v${m.version}.\n`);
+    for (const s of prov.skipped)
+        out(`  Skipped ${s.sku} v${s.version}: ${s.reason}.\n`);
+    for (const e of prov.errors) {
+        err(`  Error: could not provision the ${e.sku} module: ${e.message}\n`);
+    }
+    if (prov.errors.length > 0) {
+        throw new Error('module re-provisioning failed');
+    }
+    out('\nRestart your MCP client (Claude Desktop / Claude Code) to load Pro tools.\n');
+}

package/dist/cli/router.js

@@ -4,6 +4,7 @@ import { runStatus } from './status.js';
 import { runConfig } from './config.js';
 import { runActivate } from './activate.js';
 import { runDeactivate } from './deactivate.js';
+import { runRepair } from './repair.js';
 import { runLicenseStatus } from './license.js';
 import { runReport } from './report.js';
 import { printHelp } from './help.js';
@@ -39,6 +40,9 @@ export async function routeCli(argv, opts = {}) {
             case 'deactivate':
                 await runDeactivate({ stderr: err });
                 return { handled: true, exitCode: 0 };
+            case 'repair':
+                await runRepair({ stderr: err });
+                return { handled: true, exitCode: 0 };
             case 'license':
                 await runLicenseStatus();
                 return { handled: true, exitCode: 0 };

package/dist/core/server.js

@@ -11,16 +11,31 @@ import { Session } from './session.js';
 import { SessionLog, classifyError } from '../utils/session-log.js';
 import { loadSettings, applyTelemetryEnvOverrides, applyUpdateCheckEnvOverride, } from './settings.js';
 import { TelemetryClient } from '../telemetry/client.js';
+import { resolveInstallChannel } from '../install-channel.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';
 import { isProEntitled } from '../license/entitlement.js';
-import { loadVerifiedModule, PRO_SKU } from '../delivery/store.js';
+import { createPingLicenseRefresher } from '../license/ping-refresh.js';
+import { loadVerifiedModule, readInstalledModule, installedPath, PRO_SKU, } from '../delivery/store.js';
+import { provisionModules } from '../delivery/provision.js';
+import { readLicense } from '../license/store.js';
+import { existsSync } from 'node:fs';
 import { runScript } from '../utils/run-script.js';
 import { listTemplates } from '../utils/template-storage.js';
 import { Kernel } from '../kernel/kernel.js';
+import { HOST_MIN_ABI } from '../kernel/host-api.js';
 import { ceModule } from '../modules/ce/index.js';
+export function classifyModuleOutcome(inputs) {
+    if (inputs.proModuleLoaded && inputs.skipReason === null)
+        return 'loaded';
+    if (inputs.skipReason === 'corrupt')
+        return 'skipped_corrupt';
+    if (inputs.skipReason === 'incompatible')
+        return 'skipped_incompatible';
+    return inputs.entitled ? 'absent' : 'lapsed';
+}
 let logScriptOnErrorWarned = false;
 function warnLogScriptOnErrorOnce(logger) {
     if (logScriptOnErrorWarned)
@@ -36,8 +51,8 @@ export function __resetLogScriptOnErrorWarnForTests() {
     logScriptOnErrorWarned = false;
 }
 const FIRST_RUN_DISCLOSURE = 'First run: Editmamei collects anonymous, content-free usage telemetry (tool name, ' +
-    'success, duration, version/edition/OS/PS-version) to find what breaks. It never sends ' +
-    'image content, file paths, or personal data. Opt out anytime: ' +
+    'success, duration, version/edition/OS/PS-version, install channel) to find what breaks. ' +
+    'It never sends image content, file paths, or personal data. Opt out anytime: ' +
     '`editmamei config set telemetry.usage false` (or edit ~/.editmamei/settings.json). ' +
     'Opt in to sanitized diagnostics: `editmamei config set telemetry.diagnostics true`.';
 export class EditmameiServer {
@@ -49,9 +64,11 @@ export class EditmameiServer {
     telemetry;
     kernel;
     proModule = null;
+    moduleSkipReason = null;
     psVersion = null;
     updateInfo = null;
     snippetClient = new GoSnippetClient();
+    refreshLicenseOnPing = createPingLicenseRefresher();
     constructor() {
         this.logger = new Logger('EditmameiServer');
         this.session = new Session();
@@ -62,6 +79,9 @@ export class EditmameiServer {
         this.telemetry = new TelemetryClient({
             settings: effectiveSettings,
             getPsVersion: () => this.psVersion,
+            edition: isProEntitled() ? 'pro' : 'community',
+            channel: resolveInstallChannel(),
+            getModuleStatus: () => this.computeModuleStatus(),
         });
         if (created)
             this.logger.info(FIRST_RUN_DISCLOSURE);
@@ -202,16 +222,22 @@ export class EditmameiServer {
         if (isProEntitled()) {
             const verified = loadVerifiedModule(PRO_SKU);
             if (verified) {
+                const abi = readInstalledModule(PRO_SKU)?.abi ?? null;
                 return {
                     importer: () => import(pathToFileURL(verified.handlersPath).href),
                     binDir: verified.binDir,
+                    abi,
                 };
             }
+            if (EDITION !== 'dev' && existsSync(installedPath(PRO_SKU))) {
+                this.moduleSkipReason = 'corrupt';
+            }
         }
         if (EDITION === 'dev') {
             return {
                 importer: () => import('../modules/pro/index.js'),
                 binDir: dirname(resolveProBinaryPath()),
+                abi: null,
             };
         }
         return null;
@@ -219,14 +245,88 @@ export class EditmameiServer {
     async loadModules() {
         if (!this.proModule)
             return;
+        if (this.proModule.abi !== null && this.proModule.abi < HOST_MIN_ABI) {
+            this.logger.warn(`Pro module (abi ${this.proModule.abi}) is older than this host requires ` +
+                `(min abi ${HOST_MIN_ABI}) — booting Community; will re-provision in the background.`);
+            this.moduleSkipReason = 'incompatible';
+            return;
+        }
+        const snapshot = this.toolRegistry.snapshot();
         try {
             await this.kernel.loadDownloaded(this.proModule.importer);
+            this.assertToolsClassified();
         }
         catch (err) {
-            this.logger.warn(`Pro module not loaded: ${err instanceof Error ? err.message : String(err)}`);
+            const changed = this.toolRegistry.count() - snapshot.size;
+            this.toolRegistry.restore(snapshot);
+            this.logger.warn(`Pro module could not be loaded on this host — booting Community and rolling back ` +
+                `${changed} module tool change(s); will re-provision in the background: ` +
+                `${err instanceof Error ? err.message : String(err)}`);
+            this.moduleSkipReason = 'incompatible';
+        }
+    }
+    computeModuleStatus() {
+        if (!readLicense())
+            return null;
+        const installed = readInstalledModule(PRO_SKU);
+        return {
+            module: PRO_SKU,
+            outcome: classifyModuleOutcome({
+                proModuleLoaded: this.proModule !== null,
+                skipReason: this.moduleSkipReason,
+                entitled: isProEntitled(),
+            }),
+            module_version: installed?.version ?? null,
+            abi: installed?.abi ?? null,
+        };
+    }
+    async reprovisionIfModuleSkipped(delivery = {}) {
+        const reason = this.moduleSkipReason;
+        if (reason === null)
+            return;
+        const license = readLicense();
+        if (!license) {
+            this.logger.warn('A Pro module was skipped but no cached license was found — staying Community. ' +
+                'Run `editmamei activate <key>` to restore Pro.');
             return;
         }
-        this.assertToolsClassified();
+        try {
+            const prov = await provisionModules(license.key, {
+                force: reason === 'corrupt',
+                config: delivery.config,
+                fetchImpl: delivery.fetchImpl,
+                signingKeys: delivery.signingKeys,
+                sleep: delivery.sleep,
+            });
+            if (prov.installed.length > 0) {
+                for (const m of prov.installed) {
+                    this.logger.info(`Pro module updated to v${m.version}, restart to load.`);
+                }
+                return;
+            }
+            if (prov.notConfigured) {
+                this.logger.warn('Module delivery is not configured — staying Community.');
+                return;
+            }
+            for (const e of prov.errors) {
+                this.logger.warn(`Could not re-provision the ${e.sku} module (staying Community): ${e.message}`);
+            }
+            if (prov.errors.length === 0) {
+                if (reason === 'incompatible') {
+                    this.logger.warn('The published Pro module does not yet support this host version — staying ' +
+                        'Community. Update Editmamei when a compatible release ships; ' +
+                        '`editmamei report` files a diagnostic.');
+                }
+                else {
+                    this.logger.warn('Re-provision installed nothing for the corrupt Pro module — staying ' +
+                        'Community. Try `editmamei repair`; `editmamei report` if it persists.');
+                }
+            }
+        }
+        catch (err) {
+            this.logger.warn(`Background Pro-module re-provision failed (staying Community): ` +
+                `${err instanceof Error ? err.message : String(err)}`);
+        }
     }
     assertToolsClassified() {
         for (const tool of this.toolRegistry.list()) {
@@ -299,6 +399,7 @@ export class EditmameiServer {
         }
     }
     async pingPhotoshop() {
+        this.refreshLicenseOnPing();
         const connection = this.session.getConnection();
         const isConnected = await connection.ping();
         if (!isConnected) {
@@ -381,6 +482,7 @@ export class EditmameiServer {
         const transport = new StdioServerTransport();
         await this.server.connect(transport);
         void this.session.initialize().catch(() => undefined);
+        void this.reprovisionIfModuleSkipped();
         this.telemetry.start();
         void this.telemetry.flushOutboxOnStartup();
         this.server.onclose = () => {

package/dist/core/tool-registry.js

@@ -20,6 +20,12 @@ export class ToolRegistry {
             this.register(def.tool.name, def);
         }
     }
+    snapshot() {
+        return new Map(this.tools);
+    }
+    restore(snap) {
+        this.tools = new Map(snap);
+    }
     get(name) {
         return this.tools.get(name);
     }

package/dist/delivery/provision.js

@@ -51,7 +51,7 @@ export async function provisionModules(key, opts = {}) {
                 continue;
             }
             const installed = readInstalledModule(sku, opts);
-            if (installed && installed.version === latest) {
+            if (installed && installed.version === latest && !opts.force) {
                 result.skipped.push({ sku, version: latest, reason: 'up-to-date' });
                 continue;
             }
@@ -59,7 +59,7 @@ export async function provisionModules(key, opts = {}) {
                 result.skipped.push({
                     sku,
                     version: latest,
-                    reason: `rollback-blocked (installed v${installed.version} is newer than manifest latest v${latest})`,
+                    reason: `downgrade-blocked (installed v${installed.version} is newer than manifest latest v${latest})`,
                 });
                 continue;
             }

package/dist/delivery/store.js

@@ -1,5 +1,5 @@
 import { join, dirname } from 'node:path';
-import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, readdirSync, rmSync, lstatSync, } from 'node:fs';
 import { settingsDir } from '../core/settings.js';
 import { installBundle } from './bundle.js';
 import { sha256Hex } from './crypto.js';
@@ -7,6 +7,8 @@ import { verifyModuleSignature, MODULE_SIGNING_PUBLIC_KEYS } from './signing.js'
 import { Logger } from '../utils/logger.js';
 const logger = new Logger('Modules');
 const INSTALLED_FILENAME = 'installed.json';
+const TMP_PREFIX = '.tmp-';
+const TMP_STALE_MS = 5 * 60 * 1000;
 export const PRO_SKU = 'pro';
 export const PRO_HANDLERS_ENTRY = 'pro-handlers.mjs';
 const MODULE_MANIFEST = 'manifest.json';
@@ -72,14 +74,71 @@ function writeFileAtomic(path, data) {
     renameSync(tmp, path);
 }
 export function installModule(rec, blob, opts = {}) {
-    const dir = installedModuleDir(rec.sku, rec.version, opts);
-    installBundle(blob, rec.content_key, dir);
-    writeFileSync(moduleArtifactPath(rec.sku, rec.version, opts), Buffer.from(blob), { mode: 0o600 });
+    const finalDir = installedModuleDir(rec.sku, rec.version, opts);
+    const skuDir = dirname(finalDir);
+    const tmpDir = join(skuDir, `${TMP_PREFIX}${rec.version}-${process.pid}`);
+    rmSync(tmpDir, { recursive: true, force: true });
+    try {
+        installBundle(blob, rec.content_key, tmpDir);
+        writeFileSync(join(tmpDir, MODULE_ARTIFACT), Buffer.from(blob), { mode: 0o600 });
+    }
+    catch (err) {
+        rmSync(tmpDir, { recursive: true, force: true });
+        throw err;
+    }
+    if (opts.force && existsSync(finalDir)) {
+        rmSync(finalDir, { recursive: true, force: true });
+    }
+    try {
+        renameSync(tmpDir, finalDir);
+    }
+    catch (err) {
+        rmSync(tmpDir, { recursive: true, force: true });
+        if (!existsSync(finalDir))
+            throw err;
+    }
     const now = opts.now ?? Date.now;
     const installed = { ...rec, installed_at: new Date(now()).toISOString() };
     writeFileAtomic(installedPath(rec.sku, opts), JSON.stringify(installed, null, 2) + '\n');
+    pruneOldModuleVersions(rec.sku, rec.version, opts);
     return installed;
 }
+export function pruneOldModuleVersions(sku, keepVersion, opts = {}) {
+    const skuDir = join(modulesRoot(opts), sku);
+    if (!existsSync(skuDir))
+        return;
+    let entries;
+    try {
+        entries = readdirSync(skuDir);
+    }
+    catch (err) {
+        logger.warn(`could not list module dir for '${sku}' to prune: ${err instanceof Error ? err.message : String(err)}`);
+        return;
+    }
+    const now = (opts.now ?? Date.now)();
+    for (const entry of entries) {
+        if (entry === keepVersion || entry === INSTALLED_FILENAME)
+            continue;
+        const full = join(skuDir, entry);
+        try {
+            const st = lstatSync(full);
+            if (entry.startsWith(TMP_PREFIX)) {
+                if (now - st.mtimeMs > TMP_STALE_MS) {
+                    rmSync(full, { recursive: true, force: true });
+                    logger.info(`Pruned stale staging dir '${sku}/${entry}'.`);
+                }
+                continue;
+            }
+            if (!st.isDirectory())
+                continue;
+            rmSync(full, { recursive: true, force: true });
+            logger.info(`Pruned stale module version '${sku}' v${entry}.`);
+        }
+        catch (err) {
+            logger.warn(`could not prune stale module entry '${sku}/${entry}': ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+}
 export function loadVerifiedModule(sku, opts = {}, pubKeys = MODULE_SIGNING_PUBLIC_KEYS) {
     const rec = readInstalledModule(sku, opts);
     if (!rec)

package/dist/kernel/host-api.js

@@ -1 +1,2 @@
 export const KERNEL_ABI = 1;
+export const HOST_MIN_ABI = 1;

package/dist/license/entitlement.js

@@ -7,6 +7,7 @@ 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 const CLOCK_SKEW_TOLERANCE_MS = 24 * 60 * 60 * 1000;
 export function evaluateEntitlement(rec, now) {
     if (!rec)
         return { entitled: false, reason: 'no-license' };
@@ -77,9 +78,10 @@ export async function refreshIfStale(ops = {}) {
         return;
     const last = Date.parse(rec.last_validated_at);
     const age = Number.isFinite(last) ? now - last : Infinity;
-    if (age <= REFRESH_AFTER_MS)
+    const clockSkewed = age < -CLOCK_SKEW_TOLERANCE_MS;
+    if (!clockSkewed && age <= REFRESH_AFTER_MS)
         return;
-    if (age <= GRACE_MS) {
+    if (clockSkewed || age <= GRACE_MS) {
         refresh(ops).catch((err) => {
             logger.warn(`Background license refresh failed (grace covers offline use): ` +
                 `${err instanceof Error ? err.message : String(err)}`);

package/dist/license/ping-refresh.js

@@ -0,0 +1,14 @@
+import { refreshIfStale } from './entitlement.js';
+export function createPingLicenseRefresher(refresh = refreshIfStale) {
+    let fired = false;
+    return () => {
+        if (fired)
+            return;
+        fired = true;
+        try {
+            void refresh().catch(() => { });
+        }
+        catch {
+        }
+    };
+}

package/dist/platform/macos-executor.js

@@ -103,7 +103,6 @@ export class MacOSExecutor {
             throw new Error('jsxPath contains a character that would break AppleScript interpolation');
         }
         return `tell application "${this.appName}"
-\tactivate
 \tdo javascript "$.evalFile(decodeURI('${encodeURI(posixPath)}'))"
 end tell`;
     }

package/dist/telemetry/client.js

@@ -1,7 +1,8 @@
 import { Logger } from '../utils/logger.js';
 import { EDITION } from '../edition.js';
 import { VERSION } from '../version.js';
-import { buildDiagnosticEvent, buildSessionStart, buildSessionSummary, buildUsageEvent, dayBucket, isContentSafe, PS_VERSION_UNKNOWN, } from './events.js';
+import { resolveInstallChannel } from '../install-channel.js';
+import { buildDiagnosticEvent, buildModuleStatus, buildSessionStart, buildSessionSummary, buildUsageEvent, dayBucket, 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';
@@ -23,6 +24,7 @@ export class TelemetryClient {
     maxBatchSize;
     active;
     outboxOpts;
+    getModuleStatus;
     queue = [];
     timer = null;
     shutdownPromise = null;
@@ -39,11 +41,13 @@ export class TelemetryClient {
         this.maxBatchSize = opts.maxBatchSize ?? MAX_BATCH_SIZE;
         this.active = opts.active ?? (EDITION !== 'dev' && !isTestEnv());
         this.outboxOpts = opts.outboxDir ? { dir: opts.outboxDir } : {};
+        this.getModuleStatus = opts.getModuleStatus ?? (() => null);
         this.dims = {
             install_id: this.settings.telemetry.install_id,
             editmamei_version: VERSION,
-            edition: EDITION,
+            edition: opts.edition ?? EDITION,
             platform: process.platform,
+            channel: opts.channel ?? resolveInstallChannel(),
             getPsVersion: opts.getPsVersion,
         };
     }
@@ -57,6 +61,9 @@ export class TelemetryClient {
         this.timer.unref?.();
         if (this.settings.telemetry.usage) {
             this.enqueue(buildSessionStart(this.dims, this.now()));
+            const moduleStatus = this.getModuleStatus();
+            if (moduleStatus)
+                this.enqueue(buildModuleStatus(this.dims, moduleStatus, this.now()));
             void this.flush();
         }
     }

package/dist/telemetry/events.js

@@ -55,6 +55,22 @@ export function buildSessionStart(dims, now) {
         edition: dims.edition,
         platform: dims.platform,
         ps_version: psVersionOf(dims),
+        channel: dims.channel,
+    };
+}
+export function buildModuleStatus(dims, status, now) {
+    return {
+        v: TELEMETRY_SCHEMA_VERSION,
+        type: 'module_status',
+        install_id: dims.install_id,
+        ts_bucket: dayBucket(now),
+        editmamei_version: dims.editmamei_version,
+        edition: dims.edition,
+        platform: dims.platform,
+        module: status.module,
+        outcome: status.outcome,
+        module_version: status.module_version,
+        abi: status.abi,
     };
 }
 export function buildDiagnosticEvent(dims, diag, now) {

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.22.0';
+export const VERSION = '0.22.2';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "editmamei",
-  "version": "0.22.0",
+  "version": "0.22.2",
   "description": "Editmamei — Unlock Photoshop with natural-language photo editing (Community Edition)",
   "main": "dist/index.js",
   "type": "module",
@@ -41,7 +41,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.4",
-    "adm-zip": "^0.5.17",
+    "adm-zip": "^0.6.0",
     "jpeg-js": "^0.4.4",
     "onnxruntime-web": "1.27.0"
   }