editmamei 1.5.1 → 1.7.0

package/dist/backends/gimp/session.js

@@ -0,0 +1,632 @@
+import { spawn as nodeSpawn, spawnSync, } from 'node:child_process';
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync, copyFileSync, } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { basename, dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Logger } from '../../utils/logger.js';
+import { userOwnedTempRoot } from '../../utils/temp.js';
+import { GimpError, GIMP_ERROR_CODES } from './errors.js';
+export const READY_TIMEOUT_MS = 180_000;
+export const CALL_READY_WAIT_MS = 30_000;
+const PING_TIMEOUT_MS = 10_000;
+const DEFAULT_CALL_TIMEOUT_MS = 30_000;
+export const SHUTDOWN_GRACE_MS = 5_000;
+export const KILL_CONFIRM_MS = 2_000;
+const CLOSE_AFTER_EXIT_GRACE_MS = 500;
+const ORPHAN_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+const POLL_INTERVAL_MS = 2;
+const MAX_CAPTURED_OUTPUT = 8 * 1024;
+const RESP_READ_RETRY_ATTEMPTS = 5;
+const RESP_READ_RETRY_DELAY_MS = 20;
+const KNOWN_ERROR_CODES = new Set(GIMP_ERROR_CODES);
+const LOST_WORK = 'every open image and unsaved filter is gone — reopen the file with gimp_open_document';
+const RESTARTED_MESSAGE = `GIMP stopped; ${LOST_WORK}`;
+export function hasExited(proc) {
+    return proc.exitCode !== null || proc.signalCode !== null;
+}
+export const BATCH_LINE = "import os; g = {}; exec(open(os.environ['EM_GIMP_OPS'], encoding='utf-8').read(), g); g['serve'](os.environ['EM_GIMP_SESSION'])";
+const HERE = dirname(fileURLToPath(import.meta.url));
+export function resolveOpsPyPath() {
+    return join(HERE, 'bridge', 'ops.py');
+}
+export function defaultRootDir() {
+    return join(userOwnedTempRoot(), 'gimp');
+}
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function isEnoentError(err) {
+    return typeof err === 'object' && err !== null && err.code === 'ENOENT';
+}
+function isRetryableReadError(err) {
+    const code = typeof err === 'object' && err !== null ? err.code : undefined;
+    return code === 'EBUSY' || code === 'EPERM';
+}
+const PYTHON_INTERPRETER_MISSING_RE = /The batch interpreter '[^']*' is not available\. Batch mode disabled\.|No batch interpreters are available\. Batch mode disabled\.|The procedure '[^']*' is not a valid batch interpreter\./;
+export function defaultTreeKill(proc) {
+    if (hasExited(proc) || proc.pid === undefined)
+        return;
+    if (process.platform === 'win32') {
+        spawnSync('taskkill', ['/PID', String(proc.pid), '/T', '/F'], { windowsHide: true });
+        return;
+    }
+    try {
+        process.kill(-proc.pid, 'SIGKILL');
+    }
+    catch {
+        try {
+            proc.kill('SIGKILL');
+        }
+        catch {
+        }
+    }
+}
+export class GimpSession {
+    install;
+    rootDir;
+    spawnFn;
+    clock;
+    monotonicClock;
+    logger;
+    killTreeFn;
+    platform;
+    getuid;
+    statRootDir;
+    chmodRootDir;
+    readRespFile;
+    opsPyPath;
+    sessionState = 'idle';
+    version;
+    proc;
+    sessionDir;
+    rpcDir;
+    output = '';
+    nextId = 1;
+    queue = Promise.resolve();
+    deadGeneration = 0;
+    sweepDone = false;
+    startPromise;
+    everReady = false;
+    startOrigin;
+    unobservedStartFailure;
+    activeWaiters = 0;
+    restartNoticePending = false;
+    shutdownPromise;
+    shuttingDown = false;
+    stickyError;
+    lastFailure = new GimpError('gimp_session_restarted', RESTARTED_MESSAGE);
+    constructor(opts) {
+        this.install = opts.install;
+        this.rootDir = opts.rootDir ?? defaultRootDir();
+        this.spawnFn = opts.spawn ?? nodeSpawn;
+        this.clock = opts.now ?? Date.now;
+        this.monotonicClock = opts.nowMonotonic ?? (() => performance.now());
+        this.logger = opts.logger ?? new Logger('GimpSession');
+        this.killTreeFn = opts.killTree ?? defaultTreeKill;
+        this.platform = opts.platform ?? process.platform;
+        this.getuid = opts.getuid ?? (() => process.getuid?.());
+        this.statRootDir =
+            opts.statRootDir ??
+                ((path) => {
+                    const st = statSync(path);
+                    return { uid: st.uid, mode: st.mode };
+                });
+        this.chmodRootDir = opts.chmodRootDir ?? chmodSync;
+        this.readRespFile = opts.readRespFile ?? ((path) => readFileSync(path, 'utf8'));
+        this.opsPyPath = opts.opsPyPath ?? resolveOpsPyPath();
+    }
+    get state() {
+        return this.sessionState;
+    }
+    get gimpVersion() {
+        return this.version;
+    }
+    get lastStartOrigin() {
+        return this.startOrigin;
+    }
+    get generation() {
+        return this.deadGeneration;
+    }
+    latestPreviewPath() {
+        return join(this.rootDir, 'latest-preview.jpg');
+    }
+    tempPath(name) {
+        this.#ensureRootDir();
+        return join(this.rootDir, name);
+    }
+    copyToLatestPreview(src) {
+        this.#ensureRootDir();
+        const dest = this.latestPreviewPath();
+        const tmp = `${dest}.${process.pid}-${randomUUID()}.tmp`;
+        copyFileSync(src, tmp);
+        renameSync(tmp, dest);
+    }
+    async call(op, args = {}, callOpts = {}) {
+        const myGeneration = this.deadGeneration;
+        const issuedAt = this.monotonicClock();
+        const run = this.queue.then(() => this.#dispatch(op, args, callOpts.timeoutMs ?? DEFAULT_CALL_TIMEOUT_MS, myGeneration, issuedAt));
+        this.queue = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    async shutdown() {
+        if (!this.shutdownPromise)
+            this.shutdownPromise = this.#shutdownOnce();
+        return this.shutdownPromise;
+    }
+    async #dispatch(op, args, timeoutMs, myGeneration, issuedAt) {
+        this.#assertOpen();
+        if (this.stickyError) {
+            throw this.stickyError;
+        }
+        if (this.sessionState === 'dead' && myGeneration < this.deadGeneration) {
+            throw this.lastFailure;
+        }
+        if (this.sessionState !== 'ready') {
+            await this.#joinOrStart(issuedAt);
+            this.#assertOpen();
+        }
+        return this.#send(op, args, timeoutMs);
+    }
+    async #joinOrStart(issuedAt) {
+        if (!this.startPromise) {
+            if (this.unobservedStartFailure) {
+                const err = this.unobservedStartFailure;
+                this.unobservedStartFailure = undefined;
+                throw err;
+            }
+            const newAttempt = this.#startFresh();
+            newAttempt.catch((err) => {
+                if (this.activeWaiters > 0)
+                    return;
+                this.unobservedStartFailure =
+                    err instanceof GimpError ? err : new GimpError('gimp_start_failed', String(err));
+            });
+            this.startPromise = newAttempt;
+            const clearIfCurrent = () => {
+                if (this.startPromise === newAttempt)
+                    this.startPromise = undefined;
+            };
+            newAttempt.then(clearIfCurrent, clearIfCurrent);
+        }
+        const attempt = this.startPromise;
+        const remaining = Math.min(CALL_READY_WAIT_MS, Math.max(0, issuedAt + CALL_READY_WAIT_MS - this.monotonicClock()));
+        this.activeWaiters++;
+        let timer;
+        const timedOut = new Promise((resolve) => {
+            timer = setTimeout(() => resolve(true), remaining);
+        });
+        try {
+            const raced = await Promise.race([attempt.then(() => false), timedOut]);
+            if (raced === true) {
+                const restarting = this.startOrigin === 'restarted';
+                throw new GimpError('gimp_starting', restarting
+                    ? 'GIMP is restarting after stopping unexpectedly. Call gimp_ping again in about 30 seconds.'
+                    : 'GIMP is still starting. The first launch on a machine can take a few minutes while ' +
+                        'GIMP builds its caches. Call gimp_ping again in about 30 seconds.');
+            }
+        }
+        finally {
+            clearTimeout(timer);
+            this.activeWaiters--;
+        }
+    }
+    #assertOpen(procToKillIfTripped) {
+        if (!this.shuttingDown && this.sessionState !== 'closed')
+            return;
+        if (procToKillIfTripped)
+            this.killTreeFn(procToKillIfTripped);
+        throw new GimpError('gimp_session_restarted', 'session closed');
+    }
+    async #startFresh() {
+        this.#assertOpen();
+        this.startOrigin = this.everReady ? 'restarted' : 'cold';
+        const staleProc = this.proc;
+        const staleDir = this.sessionDir;
+        if (staleProc && !hasExited(staleProc)) {
+            await this.#killAndConfirmExit(staleProc);
+            this.#assertOpen();
+        }
+        if (staleDir) {
+            this.#removeSessionDir(staleDir);
+        }
+        this.sessionState = 'starting';
+        let sessionDir;
+        let rpcDir;
+        try {
+            this.#ensureRootDir();
+            if (!this.sweepDone) {
+                this.sweepDone = true;
+                this.#sweepOrphans();
+            }
+            sessionDir = mkdtempSync(join(this.rootDir, `session-${process.pid}-`));
+            rpcDir = join(sessionDir, 'rpc');
+            mkdirSync(rpcDir, { recursive: true });
+            this.sessionDir = sessionDir;
+            this.rpcDir = rpcDir;
+            this.nextId = 1;
+            this.output = '';
+        }
+        catch (err) {
+            const gimpErr = err instanceof GimpError
+                ? err
+                : new GimpError('gimp_start_failed', `could not prepare the GIMP session directory: ${this.#redact(err instanceof Error ? err.message : String(err))}`);
+            this.#markDead(gimpErr);
+            throw gimpErr;
+        }
+        const inherited = Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.toUpperCase().startsWith('EDITMAMEI_')));
+        const env = {
+            ...inherited,
+            EM_GIMP_OPS: this.opsPyPath,
+            EM_GIMP_SESSION: sessionDir,
+        };
+        if (this.install.launch.command !== 'flatpak') {
+            env.EM_GIMP_PARENT_PID = String(process.pid);
+        }
+        const { command, args } = this.install.launch;
+        const fullArgs = [
+            ...args,
+            '-i',
+            '--batch-interpreter=python-fu-eval',
+            '-b',
+            BATCH_LINE,
+            '--quit',
+        ];
+        let proc;
+        try {
+            proc = this.spawnFn(command, fullArgs, {
+                stdio: ['ignore', 'pipe', 'pipe'],
+                windowsHide: true,
+                detached: this.platform !== 'win32',
+                env,
+            });
+        }
+        catch (err) {
+            const gimpErr = this.#classifySpawnFailure(err);
+            this.#markDead(gimpErr);
+            throw gimpErr;
+        }
+        this.proc = proc;
+        proc.stdout?.on('data', (d) => {
+            this.output = (this.output + String(d)).slice(-MAX_CAPTURED_OUTPUT);
+        });
+        proc.stderr?.on('data', (d) => {
+            this.output = (this.output + String(d)).slice(-MAX_CAPTURED_OUTPUT);
+        });
+        let spawnError;
+        let preReadyCloseCode;
+        let closeGraceTimer;
+        proc.on('exit', (code, signal) => {
+            if (proc !== this.proc)
+                return;
+            if (this.sessionState === 'dead' || this.sessionState === 'closed')
+                return;
+            if (this.shuttingDown) {
+                this.sessionState = 'closed';
+                return;
+            }
+            if (this.sessionState === 'starting') {
+                closeGraceTimer = setTimeout(() => {
+                    if (preReadyCloseCode === undefined)
+                        preReadyCloseCode = code;
+                }, CLOSE_AFTER_EXIT_GRACE_MS);
+                closeGraceTimer.unref?.();
+                return;
+            }
+            this.logger.warn('GIMP process exited unexpectedly', { code, signal });
+            this.#markDead();
+        });
+        proc.on('close', (code) => {
+            if (proc !== this.proc)
+                return;
+            if (this.sessionState !== 'starting')
+                return;
+            clearTimeout(closeGraceTimer);
+            preReadyCloseCode = code;
+        });
+        proc.on('error', (err) => {
+            if (proc !== this.proc)
+                return;
+            spawnError = err;
+            if (this.sessionState !== 'dead' && this.sessionState !== 'closed') {
+                this.logger.error('GIMP process error', err);
+                this.#markDead(this.#classifySpawnFailure(err));
+            }
+        });
+        try {
+            await this.#waitForReady(rpcDir, () => spawnError, () => preReadyCloseCode);
+        }
+        catch (err) {
+            this.#assertOpen();
+            const gimpErr = err;
+            this.#markDead(gimpErr);
+            this.killTreeFn(proc);
+            throw gimpErr;
+        }
+        this.#assertOpen(proc);
+        let ping;
+        try {
+            ping = await this.#send('ping', {}, PING_TIMEOUT_MS);
+        }
+        catch (err) {
+            this.#assertOpen();
+            const gimpErr = err;
+            this.#markDead(gimpErr);
+            this.killTreeFn(proc);
+            throw gimpErr;
+        }
+        this.#assertOpen(proc);
+        this.version = `${ping.major}.${ping.minor}.${ping.micro}`;
+        if (ping.major !== 3 || ping.minor < 2) {
+            const err = new GimpError('gimp_version_unsupported', `Editmamei needs GIMP 3.2 or newer; found ${this.version}`);
+            this.stickyError = err;
+            this.#markDead(err);
+            this.killTreeFn(proc);
+            throw err;
+        }
+        if (ping.minor > 2) {
+            this.logger.warn(`GIMP ${this.version} is newer than the tested 3.2.x line; continuing untested`);
+        }
+        this.#assertOpen(proc);
+        this.sessionState = 'ready';
+        if (this.startOrigin === 'restarted')
+            this.restartNoticePending = true;
+        this.everReady = true;
+    }
+    #ensureRootDir() {
+        mkdirSync(this.rootDir, { recursive: true, mode: 0o700 });
+        if (this.platform === 'win32')
+            return;
+        const st = this.statRootDir(this.rootDir);
+        const uid = this.getuid();
+        if (uid !== undefined && st.uid !== uid) {
+            throw new GimpError('gimp_start_failed', `refusing to use the GIMP session folder: owned by a different user (uid ${st.uid})`);
+        }
+        if ((st.mode & 0o022) !== 0) {
+            throw new GimpError('gimp_start_failed', `refusing to use the GIMP session folder: group- or other-writable (mode ${(st.mode & 0o777).toString(8)})`);
+        }
+        this.chmodRootDir(this.rootDir, 0o700);
+    }
+    #classifySpawnFailure(err) {
+        const command = this.install.launch.command;
+        const binary = basename(command);
+        this.logger.debug('GIMP spawn failed', { command, err });
+        if (isEnoentError(err)) {
+            const gimpErr = new GimpError('gimp_start_failed', `GIMP not found at "${binary}" (ENOENT) — check the install path`);
+            this.stickyError = gimpErr;
+            return gimpErr;
+        }
+        const message = (err instanceof Error ? err.message : String(err)).split(command).join(binary);
+        return new GimpError('gimp_start_failed', `could not start GIMP at "${binary}": ${message}`);
+    }
+    async #waitForReady(rpcDir, getSpawnError, getPreReadyCloseCode) {
+        const readyPath = join(rpcDir, 'ready');
+        const deadline = this.monotonicClock() + READY_TIMEOUT_MS;
+        while (!existsSync(readyPath)) {
+            this.#assertOpen();
+            const spawnErr = getSpawnError();
+            if (spawnErr)
+                throw this.#classifySpawnFailure(spawnErr);
+            const closeCode = getPreReadyCloseCode();
+            if (closeCode !== undefined)
+                throw this.#classifyPreReadyExit(closeCode);
+            if (this.monotonicClock() > deadline) {
+                throw new GimpError('gimp_start_failed', `GIMP did not become ready within ${READY_TIMEOUT_MS}ms`);
+            }
+            await sleep(POLL_INTERVAL_MS);
+        }
+    }
+    #classifyPreReadyExit(exitCode) {
+        this.logger.debug('GIMP exited before ready', { exitCode, tail: this.output.slice(-500) });
+        if (PYTHON_INTERPRETER_MISSING_RE.test(this.output)) {
+            const gimpErr = new GimpError('gimp_python_missing', 'this GIMP install has no Python support (python-fu-eval is missing) — reinstall GIMP with Python support enabled');
+            this.stickyError = gimpErr;
+            return gimpErr;
+        }
+        return new GimpError('gimp_start_failed', `GIMP exited (code ${exitCode}) before it became ready`);
+    }
+    async #send(op, args, timeoutMs) {
+        const proc = this.proc;
+        const rpcDir = this.rpcDir;
+        if (!proc || !rpcDir) {
+            throw new GimpError('gimp_start_failed', 'GIMP session has no active process');
+        }
+        const id = this.nextId++;
+        const reqPath = join(rpcDir, `req-${id}.json`);
+        const respPath = join(rpcDir, `resp-${id}.json`);
+        writeFileSync(`${reqPath}.tmp`, JSON.stringify({ id, op, args }));
+        renameSync(`${reqPath}.tmp`, reqPath);
+        const deadline = this.monotonicClock() + timeoutMs;
+        while (!existsSync(respPath)) {
+            if (hasExited(proc) || this.sessionState === 'dead') {
+                if (!this.shuttingDown)
+                    this.#markDead();
+                throw new GimpError('gimp_session_restarted', RESTARTED_MESSAGE);
+            }
+            if (this.monotonicClock() > deadline) {
+                if (!this.shuttingDown)
+                    this.#markDead();
+                this.killTreeFn(proc);
+                throw new GimpError('gimp_timeout', `${op} did not respond within ${timeoutMs}ms, so the GIMP session was stopped: ${LOST_WORK}`);
+            }
+            await sleep(POLL_INTERVAL_MS);
+        }
+        const raw = await this.#readResponse(respPath, op);
+        try {
+            unlinkSync(respPath);
+        }
+        catch {
+        }
+        if (!raw.ok) {
+            const code = raw.code && KNOWN_ERROR_CODES.has(raw.code)
+                ? raw.code
+                : 'gimp_op_failed';
+            this.logger.debug('GIMP op failed', op, raw.error, raw.trace);
+            if (this.restartNoticePending &&
+                code === 'invalid_argument' &&
+                /no open image with id/.test(raw.error ?? '')) {
+                this.restartNoticePending = false;
+                throw new GimpError('gimp_session_restarted', `that image id is not open. The GIMP session restarted, so ${LOST_WORK}`);
+            }
+            throw new GimpError(code, this.#redact(raw.error ?? `${op} failed`));
+        }
+        if (op === 'open')
+            this.restartNoticePending = false;
+        return raw.result;
+    }
+    async #readResponse(respPath, op) {
+        let raw;
+        let lastErr;
+        for (let attempt = 0; attempt < RESP_READ_RETRY_ATTEMPTS; attempt++) {
+            try {
+                raw = this.readRespFile(respPath);
+                break;
+            }
+            catch (err) {
+                lastErr = err;
+                if (!isRetryableReadError(err)) {
+                    throw new GimpError('gimp_op_failed', `${op}: could not read the response file (${this.#redact(err.message)})`);
+                }
+                await sleep(RESP_READ_RETRY_DELAY_MS);
+            }
+        }
+        if (raw === undefined) {
+            const message = lastErr instanceof Error ? lastErr.message : String(lastErr);
+            throw new GimpError('gimp_op_failed', `${op}: could not read the response file after ${RESP_READ_RETRY_ATTEMPTS} attempts (${this.#redact(message)})`);
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch (err) {
+            throw new GimpError('gimp_op_failed', `${op}: response was not valid JSON (${err.message})`);
+        }
+        if (typeof parsed !== 'object' ||
+            parsed === null ||
+            typeof parsed.ok !== 'boolean') {
+            throw new GimpError('gimp_op_failed', `${op}: response was not a well-formed object`);
+        }
+        return parsed;
+    }
+    async #shutdownOnce() {
+        this.shuttingDown = true;
+        const proc = this.proc;
+        if (!proc) {
+            this.sessionState = 'closed';
+            if (this.sessionDir)
+                this.#removeSessionDir(this.sessionDir);
+            return;
+        }
+        if (hasExited(proc)) {
+            this.sessionState = 'closed';
+            if (this.sessionDir)
+                this.#removeSessionDir(this.sessionDir);
+            return;
+        }
+        if (this.sessionState === 'dead') {
+            await this.#killAndConfirmExit(proc);
+            this.sessionState = 'closed';
+            if (this.sessionDir)
+                this.#removeSessionDir(this.sessionDir);
+            return;
+        }
+        try {
+            writeFileSync(join(this.rpcDir, 'shutdown'), '');
+        }
+        catch {
+        }
+        let graceTimer;
+        const graceExpired = new Promise((resolve) => {
+            graceTimer = setTimeout(() => resolve(true), SHUTDOWN_GRACE_MS);
+        });
+        const exited = new Promise((resolve) => proc.once('exit', () => resolve(false)));
+        const timedOut = await Promise.race([exited, graceExpired]);
+        clearTimeout(graceTimer);
+        if (timedOut) {
+            await this.#killAndConfirmExit(proc, exited);
+        }
+        this.sessionState = 'closed';
+        if (this.sessionDir)
+            this.#removeSessionDir(this.sessionDir);
+    }
+    async #killAndConfirmExit(proc, existingExited) {
+        this.killTreeFn(proc);
+        const exited = existingExited ?? new Promise((resolve) => proc.once('exit', () => resolve(false)));
+        let confirmTimer;
+        const confirmTimedOut = new Promise((resolve) => {
+            confirmTimer = setTimeout(() => resolve(true), KILL_CONFIRM_MS);
+        });
+        const stillRunning = await Promise.race([exited.then(() => false), confirmTimedOut]);
+        clearTimeout(confirmTimer);
+        if (stillRunning) {
+            this.logger.warn('GIMP process did not confirm exit after tree-kill; proceeding anyway', {
+                sessionDir: this.sessionDir,
+            });
+        }
+    }
+    #markDead(err) {
+        if (this.sessionState === 'dead' || this.sessionState === 'closed')
+            return;
+        this.sessionState = 'dead';
+        this.deadGeneration++;
+        this.lastFailure = err ?? new GimpError('gimp_session_restarted', RESTARTED_MESSAGE);
+    }
+    #redact(text) {
+        const spellings = [
+            ...new Set([
+                this.rootDir.replace(/\\/g, '\\\\'),
+                this.rootDir,
+                this.rootDir.replace(/\\/g, '/'),
+            ]),
+        ].sort((a, b) => b.length - a.length);
+        return spellings.reduce((out, s) => out.split(s).join('<GIMP session folder>'), text);
+    }
+    #removeSessionDir(dir) {
+        try {
+            rmSync(dir, { recursive: true, force: true });
+        }
+        catch (err) {
+            this.logger.warn('Could not remove GIMP session dir', dir, err);
+        }
+    }
+    #sweepOrphans() {
+        let entries;
+        try {
+            entries = readdirSync(this.rootDir);
+        }
+        catch {
+            return;
+        }
+        const cutoff = this.clock() - ORPHAN_MAX_AGE_MS;
+        for (const name of entries) {
+            const match = /^session-(\d+)-/.exec(name);
+            if (!match)
+                continue;
+            const pid = Number(match[1]);
+            const dir = join(this.rootDir, name);
+            let mtimeMs;
+            try {
+                mtimeMs = statSync(dir).mtimeMs;
+            }
+            catch {
+                continue;
+            }
+            if (mtimeMs >= cutoff)
+                continue;
+            if (this.#isPidAlive(pid))
+                continue;
+            try {
+                rmSync(dir, { recursive: true, force: true });
+            }
+            catch (err) {
+                this.logger.warn('Could not remove orphaned GIMP session dir', dir, err);
+            }
+        }
+    }
+    #isPidAlive(pid) {
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch (err) {
+            return err.code !== 'ESRCH';
+        }
+    }
+}

package/dist/cli/config.js

@@ -1,4 +1,5 @@
 import { loadSettings, saveSettings, } from '../core/settings.js';
+import { requireAbsoluteGimpPath } from '../utils/tool-helpers.js';
 function coerceBool(raw) {
     const v = raw.trim().toLowerCase();
     if (['true', '1', 'on', 'yes'].includes(v))
@@ -11,6 +12,19 @@ function coercePath(raw) {
     const v = raw.trim();
     return v === '' || v.toLowerCase() === 'null' ? null : v;
 }
+function coerceGimpPath(raw) {
+    const v = raw.trim();
+    if (v === '' || v.toLowerCase() === 'null')
+        return null;
+    requireAbsoluteGimpPath('gimp_path', v);
+    return v;
+}
+function coerceEditorPin(raw) {
+    const v = raw.trim().toLowerCase();
+    if (v === 'auto' || v === 'photoshop' || v === 'gimp')
+        return v;
+    throw new Error(`expected one of auto|photoshop|gimp, got "${raw}"`);
+}
 const KEYS = {
     'telemetry.usage': {
         get: (s) => s.telemetry.usage,
@@ -50,6 +64,20 @@ const KEYS = {
         },
         coerce: coerceBool,
     },
+    editor: {
+        get: (s) => s.editor,
+        set: (s, v) => {
+            s.editor = v;
+        },
+        coerce: coerceEditorPin,
+    },
+    gimp_path: {
+        get: (s) => s.gimp_path,
+        set: (s, v) => {
+            s.gimp_path = v;
+        },
+        coerce: coerceGimpPath,
+    },
 };
 function knownKeysHint() {
     return `Known keys:\n${Object.keys(KEYS)