editmamei 0.22.0 → 0.22.1

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

@@ -16,10 +16,14 @@ 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 { 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';
 let logScriptOnErrorWarned = false;
 function warnLogScriptOnErrorOnce(logger) {
@@ -49,6 +53,7 @@ export class EditmameiServer {
     telemetry;
     kernel;
     proModule = null;
+    moduleSkipReason = null;
     psVersion = null;
     updateInfo = null;
     snippetClient = new GoSnippetClient();
@@ -202,16 +207,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 +230,73 @@ 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';
+        }
+    }
+    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()) {
@@ -381,6 +451,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/version.js

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

package/package.json

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