editmamei 0.24.1 → 1.0.1

package/dist/platform/connection.js

@@ -1,8 +1,5 @@
-import { platform } from 'os';
 import { Logger } from '../utils/logger.js';
-import { PhotoshopDetector } from './detector.js';
-import { WindowsExecutor } from './windows-executor.js';
-import { MacOSExecutor } from './macos-executor.js';
+import { resolveHostPlatform } from './host-platform.js';
 export function truncateForLog(s, maxLen) {
     if (s.length <= maxLen)
         return s;
@@ -11,37 +8,24 @@ export function truncateForLog(s, maxLen) {
 export const RUNNING_LATCH_TTL_MS = 30_000;
 export class PhotoshopConnection {
     logger;
-    detector;
-    executor;
+    host;
+    now;
     photoshopInfo = null;
     detectInFlight = null;
-    macosExecutor;
-    now;
     runningLatchUntil = 0;
     constructor(opts = {}) {
         this.logger = new Logger('PhotoshopConnection');
-        this.detector = new PhotoshopDetector();
         this.now = opts.now ?? Date.now;
-        const platformType = platform();
-        if (platformType === 'win32') {
-            this.executor = new WindowsExecutor();
-        }
-        else if (platformType === 'darwin') {
-            this.macosExecutor = new MacOSExecutor();
-            this.executor = this.macosExecutor;
-        }
-        else {
-            throw new Error(`Unsupported platform: ${platformType}`);
-        }
+        this.host = opts.host ?? resolveHostPlatform();
     }
     async ping() {
         try {
-            this.logger.debug('Pinging Photoshop...');
+            this.logger.debug('Pinging Photoshop');
             const result = await this.executeScript("'pong';");
             return typeof result === 'string' && result.trim() === 'pong';
         }
         catch (error) {
-            this.logger.error('Ping failed:', error);
+            this.logger.error('Ping failed', error);
             return false;
         }
     }
@@ -49,11 +33,13 @@ export class PhotoshopConnection {
         if (this.photoshopInfo)
             return this.photoshopInfo;
         if (!this.detectInFlight) {
-            this.detectInFlight = this.detector
+            this.detectInFlight = this.host.detector
                 .detect()
                 .then((info) => {
-                if (info)
+                if (info) {
+                    this.host.adapter.useInstall?.(info);
                     this.photoshopInfo = info;
+                }
                 return info;
             })
                 .finally(() => {
@@ -68,7 +54,7 @@ export class PhotoshopConnection {
             return this.photoshopInfo?.version || 'Unknown';
         }
         catch (error) {
-            this.logger.error('Failed to get version:', error);
+            this.logger.error('Failed to read the Photoshop version', error);
             throw error;
         }
     }
@@ -79,37 +65,37 @@ export class PhotoshopConnection {
                 throw new Error('Photoshop info not available — the local install could not be detected. ' +
                     'Check that Photoshop is installed (set PHOTOSHOP_PATH to override detection).');
             }
-            if (this.macosExecutor && this.photoshopInfo.appName) {
-                this.macosExecutor.setAppName(this.photoshopInfo.appName);
-            }
-            if (this.now() >= this.runningLatchUntil) {
-                const isRunning = await this.executor.isPhotoshopRunning();
-                if (!isRunning) {
-                    this.logger.info('Photoshop not running, launching...');
-                    await this.executor.launchPhotoshop(this.photoshopInfo.path);
-                }
-                else {
-                    this.runningLatchUntil = this.now() + RUNNING_LATCH_TTL_MS;
-                }
-            }
+            await this.ensureRunning(this.photoshopInfo);
             if (this.logger.isDebugEnabled()) {
-                this.logger.debug(`Executing script (${script.length} chars, PS ${this.photoshopInfo.version}, ${platform()}): ${truncateForLog(script, 200)}`);
+                this.logger.debug(`Executing script (${script.length} chars, PS ${this.photoshopInfo.version}, ${this.host.os}): ${truncateForLog(script, 200)}`);
             }
-            const result = await this.executor.execute(script, timeout);
+            const result = await this.host.adapter.run(script, timeout);
             this.runningLatchUntil = this.now() + RUNNING_LATCH_TTL_MS;
             return result;
         }
         catch (error) {
             this.runningLatchUntil = 0;
-            const psVersion = this.photoshopInfo?.version ?? 'unknown';
-            const head = truncateForLog(script, 200);
-            this.logger.error(`Script execution failed (PS ${psVersion}, ${platform()}, ${script.length} chars):`, error, `\n--- script head (200 chars) ---\n${head}`);
-            if (process.env.LOG_SCRIPT_ON_ERROR === '1') {
-                this.logger.error(`--- full failing script ---\n${script}\n--- end script ---`);
-            }
+            this.logFailure(script, error);
             throw error;
         }
     }
+    async ensureRunning(info) {
+        if (this.now() < this.runningLatchUntil)
+            return;
+        if (await this.host.adapter.isRunning()) {
+            this.runningLatchUntil = this.now() + RUNNING_LATCH_TTL_MS;
+            return;
+        }
+        this.logger.info('Photoshop is not running; launching it');
+        await this.host.adapter.launch(info.path);
+    }
+    logFailure(script, error) {
+        const psVersion = this.photoshopInfo?.version ?? 'unknown';
+        this.logger.error(`Script execution failed (PS ${psVersion}, ${this.host.os}, ${script.length} chars)`, error, `\n--- script head (200 chars) ---\n${truncateForLog(script, 200)}`);
+        if (process.env.LOG_SCRIPT_ON_ERROR === '1') {
+            this.logger.error(`--- full failing script ---\n${script}\n--- end script ---`);
+        }
+    }
     getPhotoshopInfo() {
         return this.photoshopInfo;
     }

package/dist/platform/host-platform.js

@@ -0,0 +1,16 @@
+import { platform } from 'os';
+import { MacOSDetector } from './macos-detector.js';
+import { MacOSScriptRunner } from './macos-runner.js';
+import { WindowsDetector } from './windows-detector.js';
+import { WindowsScriptRunner } from './windows-runner.js';
+export function resolveHostPlatform() {
+    const os = platform();
+    if (os === 'win32') {
+        return { os, adapter: new WindowsScriptRunner(), detector: new WindowsDetector() };
+    }
+    if (os === 'darwin') {
+        return { os, adapter: new MacOSScriptRunner(), detector: new MacOSDetector() };
+    }
+    throw new Error(`Editmamei runs on Windows and macOS; this process is on "${os}". ` +
+        'Adobe ships no Linux build of Photoshop, so there is nothing here to drive.');
+}

package/dist/platform/macos-detector.js

@@ -3,136 +3,106 @@ import { promisify } from 'util';
 import { access, constants, readFile } from 'fs/promises';
 import { Logger } from '../utils/logger.js';
 const execFileAsync = promisify(execFile);
+export function bundleDisplayName(bundlePath) {
+    const leaf = bundlePath.replace(/\/+$/, '').split('/').pop();
+    if (!leaf)
+        return undefined;
+    return leaf.endsWith('.app') ? leaf.slice(0, -'.app'.length) : leaf;
+}
 export class MacOSDetector {
-    logger;
-    constructor() {
-        this.logger = new Logger('MacOSDetector');
-    }
+    logger = new Logger('MacOSDetector');
     async detect() {
-        this.logger.info('Detecting Photoshop on macOS...');
-        const envPath = process.env.PHOTOSHOP_PATH;
-        if (envPath) {
-            this.logger.debug(`Using environment variable: ${envPath}`);
-            const info = await this.checkPath(envPath);
+        this.logger.info('Looking for a Photoshop install on macOS');
+        const override = process.env.PHOTOSHOP_PATH;
+        if (override) {
+            this.logger.debug('Trying PHOTOSHOP_PATH override', override);
+            const info = await this.inspectBundle(override);
             if (info)
                 return info;
         }
         try {
-            const spotlightInfo = await this.detectUsingSpotlight();
-            if (spotlightInfo)
-                return spotlightInfo;
+            const fromSpotlight = await this.findViaSpotlight();
+            if (fromSpotlight)
+                return fromSpotlight;
         }
         catch (error) {
-            this.logger.warn('Spotlight detection failed:', error);
+            this.logger.warn('Spotlight lookup did not resolve an install', error);
         }
-        const commonPaths = this.getCommonPaths();
-        for (const path of commonPaths) {
-            const info = await this.checkPath(path);
+        for (const path of this.conventionalPaths()) {
+            const info = await this.inspectBundle(path);
             if (info)
                 return info;
         }
-        throw new Error('Photoshop not found on this system');
+        throw new Error('No Photoshop install could be found on this machine');
     }
-    async detectUsingSpotlight() {
+    async findViaSpotlight() {
         try {
             const { stdout } = await execFileAsync('mdfind', [
                 'kMDItemCFBundleIdentifier == com.adobe.Photoshop',
             ]);
-            const apps = stdout
+            const bundles = stdout
                 .split('\n')
                 .filter((line) => line.trim() && line.endsWith('.app'))
                 .sort((a, b) => b.localeCompare(a));
-            for (const appPath of apps) {
-                const info = await this.checkPath(appPath);
+            for (const bundlePath of bundles) {
+                const info = await this.inspectBundle(bundlePath);
                 if (info)
                     return info;
             }
         }
         catch (error) {
-            this.logger.debug('Spotlight search failed:', error);
+            this.logger.debug('Spotlight query failed', error);
         }
         return null;
     }
-    getCommonPaths() {
+    conventionalPaths() {
         const paths = [];
-        const maxYear = Math.max(new Date().getFullYear() + 1, 2026);
-        for (let year = maxYear; year >= 2012; year--) {
+        const newestYear = Math.max(new Date().getFullYear() + 1, 2026);
+        for (let year = newestYear; year >= 2012; year--) {
             paths.push(`/Applications/Adobe Photoshop ${year}/Adobe Photoshop ${year}.app`, `/Applications/Adobe Photoshop CC ${year}/Adobe Photoshop CC ${year}.app`, `/Applications/Adobe Photoshop ${year}.app`);
         }
         paths.push('/Applications/Adobe Photoshop CC/Adobe Photoshop CC.app', '/Applications/Adobe Photoshop/Adobe Photoshop.app', '/Applications/Adobe Photoshop.app');
         return paths;
     }
-    async checkPath(path) {
+    async inspectBundle(path) {
         try {
             const cleanPath = path.trim();
             await access(cleanPath, constants.F_OK);
-            const version = await this.extractVersionFromApp(cleanPath);
-            const appName = cleanPath.split('/').pop()?.replace('.app', '') || 'Adobe Photoshop 2025';
-            this.logger.info(`Found Photoshop at: ${cleanPath}`);
-            return {
-                version,
-                path: cleanPath,
-                isRunning: await this.checkIfRunning(cleanPath),
-                appName,
-            };
+            const version = await this.readBundleVersion(cleanPath);
+            const appName = bundleDisplayName(cleanPath);
+            this.logger.info('Using Photoshop at', cleanPath);
+            return { version, path: cleanPath, appName };
         }
         catch {
             return null;
         }
     }
-    async extractVersionFromApp(appPath) {
+    async readBundleVersion(bundlePath) {
         try {
-            const plistPath = `${appPath}/Contents/Info.plist`;
+            const plistPath = `${bundlePath}/Contents/Info.plist`;
             try {
                 await access(plistPath, constants.F_OK);
-                const { stdout: version } = await execFileAsync('/usr/libexec/PlistBuddy', [
+                const { stdout } = await execFileAsync('/usr/libexec/PlistBuddy', [
                     '-c',
                     'Print :CFBundleShortVersionString',
                     plistPath,
                 ]);
-                if (version.trim()) {
-                    return version.trim();
-                }
+                if (stdout.trim())
+                    return stdout.trim();
             }
             catch {
                 const content = await readFile(plistPath, 'utf8');
                 const versionMatch = content.match(/<key>CFBundleShortVersionString<\/key>\s*<string>([^<]+)<\/string>/);
-                if (versionMatch) {
+                if (versionMatch)
                     return versionMatch[1];
-                }
             }
-            const yearMatch = appPath.match(/(\d{4})/);
-            if (yearMatch) {
+            const yearMatch = bundlePath.match(/(\d{4})/);
+            if (yearMatch)
                 return yearMatch[1];
-            }
         }
         catch (err) {
-            this.logger.debug('Failed to extract version from app:', err);
+            this.logger.debug('Could not read a version from the bundle', err);
         }
         return 'Unknown';
     }
-    async checkIfRunning(appPath) {
-        try {
-            const appName = appPath.split('/').pop()?.replace('.app', '') || 'Adobe Photoshop';
-            const { stdout } = await execFileAsync('pgrep', ['-f', appName]);
-            return stdout.trim().length > 0;
-        }
-        catch {
-            return false;
-        }
-    }
-    async getAppBundleId(appPath) {
-        try {
-            const plistPath = `${appPath}/Contents/Info.plist`;
-            const { stdout } = await execFileAsync('/usr/libexec/PlistBuddy', [
-                '-c',
-                'Print :CFBundleIdentifier',
-                plistPath,
-            ]);
-            return stdout.trim();
-        }
-        catch {
-            return null;
-        }
-    }
 }

package/dist/platform/macos-runner.js

@@ -0,0 +1,94 @@
+import { exec, spawn } from 'child_process';
+import { promisify } from 'util';
+import { Logger } from '../utils/logger.js';
+import { TempDir } from '../utils/temp.js';
+import { ScriptQueue } from './script-queue.js';
+import { runChildWithTimeout } from './run-child.js';
+import { decodeScriptResult } from './script-result.js';
+const execAsync = promisify(exec);
+const DEFAULT_SCRIPT_TIMEOUT_MS = 30_000;
+const LAUNCH_GRACE_MS = 5_000;
+const UNSAFE_IN_APPLESCRIPT_LITERAL = /["\\\r\n\t]/;
+export class MacOSScriptRunner {
+    logger = new Logger('MacOSScriptRunner');
+    queue = new ScriptQueue(this.logger);
+    appName = null;
+    useInstall(install) {
+        const name = install.appName;
+        if (!name) {
+            this.logger.warn('This Photoshop install carries no application name, so AppleScript has nothing to address', install.path);
+            return;
+        }
+        if (UNSAFE_IN_APPLESCRIPT_LITERAL.test(name)) {
+            throw new Error(`Photoshop's application name (${JSON.stringify(name)}) contains a character that ` +
+                'cannot be composed into AppleScript.');
+        }
+        this.appName = name;
+        this.logger.debug('Addressing Photoshop as', name);
+    }
+    async run(script, timeoutMs = DEFAULT_SCRIPT_TIMEOUT_MS) {
+        return this.queue.enqueue(() => this.runOnce(script, timeoutMs), timeoutMs);
+    }
+    async runOnce(script, timeoutMs) {
+        const dir = await TempDir.create('editmamei-mac-');
+        try {
+            const scriptPath = await dir.write('script.jsx', script);
+            const wrapperPath = await dir.write('run.scpt', this.buildAppleScriptWrapper(scriptPath, timeoutMs));
+            const { stdout, stderr, exitCode } = await runChildWithTimeout('osascript', [wrapperPath], {
+                timeout: timeoutMs,
+                diagLabel: 'osascript run.scpt',
+            });
+            if (stderr) {
+                this.logger.warn('Script execution reported a warning', stderr);
+            }
+            if (exitCode !== 0) {
+                throw new Error(`osascript exited with code ${exitCode}: ${stderr.trim() || '(no output on stderr)'}`);
+            }
+            return decodeScriptResult(stdout);
+        }
+        finally {
+            await dir.cleanup();
+        }
+    }
+    buildAppleScriptWrapper(scriptPath, timeoutMs = DEFAULT_SCRIPT_TIMEOUT_MS) {
+        if (!this.appName) {
+            throw new Error('No Photoshop application name has been set for this runner — the install was never ' +
+                'handed to useInstall(), so there is no application for AppleScript to address.');
+        }
+        const posixPath = scriptPath.replace(/\\/g, '/');
+        if (posixPath.includes('"') || posixPath.includes('\n')) {
+            throw new Error('Refusing to compose the wrapper: script path would break the AppleScript');
+        }
+        const timeoutSeconds = Number.isFinite(timeoutMs) && timeoutMs > 0 ? Math.max(1, Math.ceil(timeoutMs / 1000)) : 1;
+        const encodedPath = encodeURI(posixPath).replace(/'/g, '%27');
+        return `with timeout of ${timeoutSeconds} seconds
+\ttell application "${this.appName}"
+\t\tdo javascript "$.evalFile(decodeURI('${encodedPath}'))"
+\tend tell
+end timeout`;
+    }
+    async isRunning() {
+        try {
+            const { stdout } = await execAsync('pgrep -f "Adobe Photoshop"');
+            return stdout.trim().length > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    async launch(executablePath) {
+        return new Promise((resolve, reject) => {
+            this.logger.info('Launching Photoshop', executablePath);
+            const child = spawn('open', ['-a', executablePath], { detached: true, stdio: 'ignore' });
+            child.unref();
+            const grace = setTimeout(() => {
+                grace.unref();
+                resolve();
+            }, LAUNCH_GRACE_MS);
+            child.on('error', (error) => {
+                clearTimeout(grace);
+                reject(new Error(`Could not launch Photoshop at ${executablePath}: ${error.message}`));
+            });
+        });
+    }
+}

package/dist/platform/script-result.js

@@ -0,0 +1,39 @@
+const TRANSPORT_FAILURE_MARKER = 'ERROR:';
+const ENVELOPE_TAG = '__em';
+function isEnvelope(payload) {
+    return (typeof payload === 'object' &&
+        payload !== null &&
+        ENVELOPE_TAG in payload);
+}
+export class PhotoshopScriptError extends Error {
+    psErrorNumber;
+    psLine;
+    constructor(message, psErrorNumber = null, psLine = null) {
+        super(message);
+        this.name = 'PhotoshopScriptError';
+        this.psErrorNumber = psErrorNumber;
+        this.psLine = psLine;
+    }
+}
+function asNumberOrNull(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+export function decodeScriptResult(raw) {
+    const payload = raw.trim();
+    if (payload.startsWith(TRANSPORT_FAILURE_MARKER)) {
+        throw new PhotoshopScriptError(payload.slice(TRANSPORT_FAILURE_MARKER.length).trim());
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(payload);
+    }
+    catch {
+        return payload;
+    }
+    if (!isEnvelope(parsed))
+        return parsed;
+    if (parsed.ok)
+        return parsed.value;
+    const detail = parsed.error ?? {};
+    throw new PhotoshopScriptError(typeof detail.message === 'string' ? detail.message : '', asNumberOrNull(detail.number), asNumberOrNull(detail.line));
+}

package/dist/platform/windows-detector.js

@@ -4,46 +4,42 @@ import { access, constants } from 'fs/promises';
 import { Logger } from '../utils/logger.js';
 const execAsync = promisify(exec);
 export class WindowsDetector {
-    logger;
-    constructor() {
-        this.logger = new Logger('WindowsDetector');
-    }
+    logger = new Logger('WindowsDetector');
     async detect() {
-        this.logger.info('Detecting Photoshop on Windows...');
-        const envPath = process.env.PHOTOSHOP_PATH;
-        if (envPath) {
-            this.logger.debug(`Using environment variable: ${envPath}`);
-            const info = await this.checkPath(envPath);
+        this.logger.info('Looking for a Photoshop install on Windows');
+        const override = process.env.PHOTOSHOP_PATH;
+        if (override) {
+            this.logger.debug('Trying PHOTOSHOP_PATH override', override);
+            const info = await this.inspectPath(override);
             if (info)
                 return info;
         }
         try {
-            const registryInfo = await this.detectFromRegistry();
-            if (registryInfo)
-                return registryInfo;
+            const fromRegistry = await this.findViaRegistry();
+            if (fromRegistry)
+                return fromRegistry;
         }
         catch (error) {
-            this.logger.warn('Registry detection failed:', error);
+            this.logger.warn('Registry lookup did not resolve an install', error);
         }
-        const commonPaths = this.getCommonPaths();
-        const commonPathInfo = await this.checkCommonPaths(commonPaths);
-        if (commonPathInfo)
-            return commonPathInfo;
-        throw new Error('Photoshop not found on this system');
+        const fromConventionalPaths = await this.probeCandidates(this.conventionalPaths());
+        if (fromConventionalPaths)
+            return fromConventionalPaths;
+        throw new Error('No Photoshop install could be found on this machine');
     }
-    async detectFromRegistry() {
+    async findViaRegistry() {
         try {
-            const registryPaths = [
+            const productKeys = [
                 'HKLM\\SOFTWARE\\Adobe\\Photoshop',
                 'HKLM\\SOFTWARE\\WOW6432Node\\Adobe\\Photoshop',
             ];
-            for (const regPath of registryPaths) {
+            for (const key of productKeys) {
                 try {
-                    const { stdout } = await execAsync(`reg query "${regPath}" /s`);
-                    const entries = this.parseRegistryOutput(stdout);
+                    const { stdout } = await execAsync(`reg query "${key}" /s`);
+                    const entries = this.readRegistryEntries(stdout);
                     if (entries.length > 0) {
-                        const latest = entries.sort((a, b) => b.version.localeCompare(a.version))[0];
-                        const info = await this.checkPath(latest.path);
+                        const newest = entries.sort((a, b) => b.version.localeCompare(a.version))[0];
+                        const info = await this.inspectPath(newest.path);
                         if (info)
                             return info;
                     }
@@ -52,16 +48,16 @@ export class WindowsDetector {
                     continue;
                 }
             }
-            const clsidPaths = [
+            const comRegistrations = [
                 'HKCR\\CLSID\\{06870682-6f3c-4b97-9143-f03e85c0bd3e}\\LocalServer32',
                 'HKCR\\Wow6432Node\\CLSID\\{06870682-6f3c-4b97-9143-f03e85c0bd3e}\\LocalServer32',
             ];
-            for (const clsidPath of clsidPaths) {
+            for (const key of comRegistrations) {
                 try {
-                    const { stdout } = await execAsync(`reg query "${clsidPath}" /ve`);
-                    const exePath = this.extractPathFromCLSID(stdout);
+                    const { stdout } = await execAsync(`reg query "${key}" /ve`);
+                    const exePath = this.readComServerPath(stdout);
                     if (exePath) {
-                        const info = await this.checkPath(exePath);
+                        const info = await this.inspectPath(exePath);
                         if (info)
                             return info;
                     }
@@ -72,91 +68,71 @@ export class WindowsDetector {
             }
         }
         catch (err) {
-            this.logger.error('Registry query failed:', err);
+            this.logger.error('Registry query failed outright', err);
         }
         return null;
     }
-    parseRegistryOutput(output) {
+    readRegistryEntries(output) {
         const entries = [];
-        const lines = output.split('\n');
         let currentVersion = '';
-        for (const line of lines) {
+        for (const line of output.split('\n')) {
             const versionMatch = line.match(/Photoshop\\(\d+\.\d+)/);
             if (versionMatch) {
                 currentVersion = versionMatch[1];
             }
             const pathMatch = line.match(/ApplicationPath\s+REG_SZ\s+(.+)/);
             if (pathMatch && currentVersion) {
-                entries.push({
-                    version: currentVersion,
-                    path: pathMatch[1].trim(),
-                });
+                entries.push({ version: currentVersion, path: pathMatch[1].trim() });
             }
         }
         return entries;
     }
-    extractPathFromCLSID(output) {
+    readComServerPath(output) {
         const match = output.match(/REG_SZ\s+"?(.+?\.exe)"?/i);
         if (!match)
             return null;
         return match[1].trim();
     }
-    getCommonPaths() {
+    conventionalPaths() {
         const programFiles = process.env.ProgramFiles || 'C:\\Program Files';
         const programFilesX86 = process.env['ProgramFiles(x86)'] || 'C:\\Program Files (x86)';
         const paths = [];
-        const maxYear = Math.max(new Date().getFullYear() + 1, 2026);
-        for (let year = maxYear; year >= 2012; year--) {
+        const newestYear = Math.max(new Date().getFullYear() + 1, 2026);
+        for (let year = newestYear; year >= 2012; year--) {
             paths.push(`${programFiles}\\Adobe\\Adobe Photoshop ${year}\\Photoshop.exe`, `${programFilesX86}\\Adobe\\Adobe Photoshop ${year}\\Photoshop.exe`, `${programFiles}\\Adobe\\Adobe Photoshop CC ${year}\\Photoshop.exe`, `${programFilesX86}\\Adobe\\Adobe Photoshop CC ${year}\\Photoshop.exe`);
         }
         paths.push(`${programFiles}\\Adobe\\Adobe Photoshop CC\\Photoshop.exe`, `${programFiles}\\Adobe\\Photoshop CC\\Photoshop.exe`);
         return paths;
     }
-    async checkCommonPaths(paths) {
-        const results = await Promise.all(paths.map((path) => this.checkPath(path)));
+    async probeCandidates(candidates) {
+        const results = await Promise.all(candidates.map((path) => this.inspectPath(path)));
         const selected = results.find((result) => result !== null) ?? null;
         if (selected) {
-            this.logger.info(`Found Photoshop at: ${selected.path}`);
+            this.logger.info('Using Photoshop at', selected.path);
         }
         return selected;
     }
-    async checkPath(path) {
+    async inspectPath(path) {
         try {
             let cleanPath = path.trim().replace(/^"|"$/g, '');
             if (!cleanPath.toLowerCase().endsWith('.exe')) {
-                cleanPath = `${cleanPath}\\Photoshop.exe`;
+                cleanPath = `${cleanPath.replace(/[\\/]+$/, '')}\\Photoshop.exe`;
             }
             await access(cleanPath, constants.F_OK);
-            const version = this.extractVersionFromPath(cleanPath);
-            this.logger.debug(`Found Photoshop at: ${cleanPath}`);
-            return {
-                version,
-                path: cleanPath,
-                isRunning: await this.checkIfRunning(),
-            };
+            this.logger.debug('Candidate install exists', cleanPath);
+            return { version: this.readVersionFromPath(cleanPath), path: cleanPath };
         }
         catch {
             return null;
         }
     }
-    extractVersionFromPath(path) {
+    readVersionFromPath(path) {
         const yearMatch = path.match(/(\d{4})/);
-        if (yearMatch) {
+        if (yearMatch)
             return yearMatch[1];
-        }
         const versionMatch = path.match(/(\d+\.\d+)/);
-        if (versionMatch) {
+        if (versionMatch)
             return versionMatch[1];
-        }
         return 'Unknown';
     }
-    async checkIfRunning() {
-        try {
-            const { stdout } = await execAsync('tasklist /FI "IMAGENAME eq Photoshop.exe"');
-            return stdout.toLowerCase().includes('photoshop.exe');
-        }
-        catch {
-            return false;
-        }
-    }
 }