agent-muster 0.1.0

package/dist/server.js

@@ -0,0 +1,283 @@
+import express from 'express';
+import { execFile } from 'node:child_process';
+import { createServer } from 'node:http';
+import { readdir, realpath, stat } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { promisify } from 'node:util';
+const webRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../web/dist');
+const execFileAsync = promisify(execFile);
+async function chooseProjectDirectory() {
+    const platform = process.platform;
+    const command = platform === 'darwin' ? 'osascript' : platform === 'win32' ? 'powershell.exe' : 'zenity';
+    const args = platform === 'darwin'
+        ? ['-e', 'try\nPOSIX path of (choose folder with prompt "选择项目目录")\non error number -128\nreturn ""\nend try']
+        : platform === 'win32'
+            ? ['-NoProfile', '-STA', '-Command', 'Add-Type -AssemblyName System.Windows.Forms; $dialog = New-Object System.Windows.Forms.FolderBrowserDialog; if ($dialog.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) { [Console]::Write($dialog.SelectedPath) }']
+            : ['--file-selection', '--directory', '--title=选择项目目录'];
+    try {
+        const { stdout } = await execFileAsync(command, args);
+        return stdout.trim() || null;
+    }
+    catch (error) {
+        if (platform === 'linux' && error.code === 1)
+            return null;
+        throw error;
+    }
+}
+export async function startServer(port, registry, projects, sessions, dingtalk) {
+    const app = express();
+    app.disable('x-powered-by');
+    app.use((request, response, next) => {
+        if (request.headers.host !== `127.0.0.1:${port}`) {
+            response.status(403).json({ error: 'Invalid host' });
+            return;
+        }
+        if (request.method !== 'GET' && request.method !== 'HEAD') {
+            const origin = request.headers.origin;
+            if (origin && origin !== `http://127.0.0.1:${port}`) {
+                response.status(403).json({ error: 'Invalid origin' });
+                return;
+            }
+        }
+        next();
+    });
+    app.use('/api', express.json({ limit: '128kb' }));
+    app.get('/api/agents', (_request, response) => response.json(registry.list()));
+    app.get('/api/projects', (_request, response) => response.json(projects.list()));
+    app.post('/api/projects', async (request, response) => {
+        try {
+            if (typeof request.body?.path !== 'string')
+                throw new Error('Project directory is required');
+            response.status(201).json({ path: await projects.add(request.body.path) });
+        }
+        catch (error) {
+            response.status(400).json({ error: error.message });
+        }
+    });
+    app.post('/api/projects/pick', async (_request, response) => {
+        try {
+            const path = await chooseProjectDirectory();
+            response.json({ path: path ? await projects.add(path) : null });
+        }
+        catch (error) {
+            response.status(500).json({ error: error.message });
+        }
+    });
+    app.delete('/api/projects', async (request, response) => {
+        try {
+            const path = request.body?.path;
+            const projectSessions = typeof path === 'string' ? sessions.list().filter(item => item.cwd === path) : [];
+            const registered = typeof path === 'string' && projects.list().includes(path);
+            if (typeof path !== 'string' || (!registered && !projectSessions.length)) {
+                response.status(404).json({ error: 'Project not found' });
+                return;
+            }
+            await dingtalk.unbindProject(path);
+            for (const session of projectSessions) {
+                await dingtalk.unbindSession(session.id);
+                await sessions.remove(session.id);
+            }
+            if (registered)
+                await projects.remove(path);
+            response.json({ path });
+        }
+        catch (error) {
+            response.status(500).json({ error: error.message });
+        }
+    });
+    app.get('/api/dingtalk/apps', (_request, response) => response.json(dingtalk.list()));
+    app.get('/api/dingtalk/apps/:id/icon', async (request, response) => {
+        try {
+            const icon = await dingtalk.getIcon(request.params.id);
+            if (!icon) {
+                response.status(404).end();
+                return;
+            }
+            response.type(icon.mime).send(icon.data);
+        }
+        catch (error) {
+            response.status(500).json({ error: error.message });
+        }
+    });
+    app.post('/api/dingtalk/apps/:id/sync', async (request, response) => {
+        try {
+            response.json(await dingtalk.syncMetadata(request.params.id));
+        }
+        catch (error) {
+            response.status(502).json({ error: error.message });
+        }
+    });
+    app.post('/api/dingtalk/registration', async (_request, response) => {
+        try {
+            response.status(201).json(await dingtalk.start());
+        }
+        catch (error) {
+            response.status(502).json({ error: error.message });
+        }
+    });
+    app.get('/api/dingtalk/registration/:id', async (request, response) => {
+        try {
+            response.json(await dingtalk.poll(request.params.id));
+        }
+        catch (error) {
+            response.status(502).json({ error: error.message });
+        }
+    });
+    app.patch('/api/dingtalk/apps/:id', async (request, response) => {
+        try {
+            const { project, agent } = request.body || {};
+            if (project !== undefined && project !== null && typeof project !== 'string')
+                throw new Error('项目无效');
+            if (agent !== undefined && agent !== null && typeof agent !== 'string')
+                throw new Error('Agent 无效');
+            response.json(await dingtalk.bind(request.params.id, { project, agent }, projects.list(), registry.list().filter(item => item.installed).map(item => item.id)));
+        }
+        catch (error) {
+            response.status(400).json({ error: error.message });
+        }
+    });
+    app.delete('/api/dingtalk/apps/:id', async (request, response) => {
+        try {
+            if (!dingtalk.getBinding(request.params.id)) {
+                response.status(404).json({ error: '钉钉应用不存在' });
+                return;
+            }
+            await dingtalk.remove(request.params.id);
+            response.json({ id: request.params.id });
+        }
+        catch (error) {
+            response.status(500).json({ error: error.message });
+        }
+    });
+    app.get('/api/sessions', (_request, response) => response.json(sessions.list()));
+    app.get('/api/sessions/:id', (request, response) => {
+        const session = sessions.get(request.params.id);
+        if (!session) {
+            response.status(404).json({ error: 'Session not found' });
+            return;
+        }
+        response.json(session);
+    });
+    app.get('/api/directories', async (request, response) => {
+        try {
+            const requested = typeof request.query.path === 'string' ? request.query.path : process.cwd();
+            if (!isAbsolute(requested))
+                throw new Error('Absolute path required');
+            const path = await realpath(requested);
+            if (!(await stat(path)).isDirectory())
+                throw new Error('Directory required');
+            const entries = await readdir(path, { withFileTypes: true });
+            response.json({
+                path,
+                parent: dirname(path),
+                home: homedir(),
+                directories: entries.filter(entry => entry.isDirectory() && !entry.name.startsWith('.'))
+                    .map(entry => entry.name).sort((a, b) => a.localeCompare(b)),
+            });
+        }
+        catch (error) {
+            response.status(400).json({ error: error.message });
+        }
+    });
+    app.post('/api/sessions', async (request, response) => {
+        try {
+            const { agent, cwd, prompt, model } = request.body || {};
+            if (typeof agent !== 'string' || !registry.get(agent)?.installed)
+                throw new Error('Agent is not installed');
+            if (typeof cwd !== 'string' || typeof prompt !== 'string')
+                throw new Error('Project and prompt are required');
+            if (model !== undefined && (typeof model !== 'string' || (model && !registry.get(agent)?.models.some(item => item.id === model))))
+                throw new Error('Invalid model');
+            response.status(201).json(await sessions.create(agent, cwd, prompt, model || undefined));
+        }
+        catch (error) {
+            response.status(400).json({ error: error.message });
+        }
+    });
+    app.post('/api/sessions/:id/messages', (request, response) => {
+        try {
+            const { content, model } = request.body || {};
+            if (typeof content !== 'string')
+                throw new Error('Message is required');
+            const session = sessions.get(request.params.id);
+            if (!session)
+                throw new Error('Session not found');
+            if (model !== undefined && (typeof model !== 'string' || (model && !registry.get(session.agent)?.models.some(item => item.id === model))))
+                throw new Error('Invalid model');
+            response.json(sessions.send(request.params.id, content, model));
+        }
+        catch (error) {
+            response.status(400).json({ error: error.message });
+        }
+    });
+    app.post('/api/sessions/:id/dingtalk/messages', async (request, response) => {
+        try {
+            const { content } = request.body || {};
+            if (typeof content !== 'string' || !content.trim())
+                throw new Error('Message is required');
+            const session = sessions.get(request.params.id);
+            if (!session)
+                throw new Error('Session not found');
+            if (!session.dingtalkAppId)
+                throw new Error('此对话未关联钉钉应用');
+            await dingtalk.sendToSession(session.dingtalkAppId, session.id, content.trim());
+            response.json(sessions.recordDingTalkMessage(session.id, content.trim()));
+        }
+        catch (error) {
+            console.error(`DingTalk message sending failed for session ${request.params.id}:`, error);
+            response.status(400).json({ error: error.message });
+        }
+    });
+    app.post('/api/sessions/:id/stop', (request, response) => {
+        try {
+            response.json(sessions.stop(request.params.id));
+        }
+        catch (error) {
+            response.status(400).json({ error: error.message });
+        }
+    });
+    app.delete('/api/sessions/:id', async (request, response) => {
+        try {
+            if (!sessions.get(request.params.id)) {
+                response.status(404).json({ error: 'Session not found' });
+                return;
+            }
+            await dingtalk.unbindSession(request.params.id);
+            await sessions.remove(request.params.id);
+            response.json({ id: request.params.id });
+        }
+        catch (error) {
+            response.status(500).json({ error: error.message });
+        }
+    });
+    app.get('/api/sessions/:id/events', (request, response) => {
+        const session = sessions.get(request.params.id);
+        if (!session) {
+            response.status(404).json({ error: 'Session not found' });
+            return;
+        }
+        response.setHeader('Content-Type', 'text/event-stream');
+        response.setHeader('Cache-Control', 'no-cache');
+        response.setHeader('Connection', 'keep-alive');
+        response.flushHeaders();
+        const after = Math.max(Number(request.query.after || 0), Number(request.headers['last-event-id'] || 0));
+        const send = (event) => response.write(`id: ${event.id}\ndata: ${JSON.stringify(event)}\n\n`);
+        for (const event of session.events)
+            if (event.id > after)
+                send(event);
+        const listener = (event) => send(event);
+        sessions.on(session.id, listener);
+        const heartbeat = setInterval(() => response.write(': keepalive\n\n'), 15000);
+        request.on('close', () => { clearInterval(heartbeat); sessions.off(session.id, listener); });
+    });
+    app.use(express.static(webRoot));
+    app.get('/{*path}', (_request, response) => response.sendFile(join(webRoot, 'index.html')));
+    const server = createServer(app);
+    await new Promise((done, reject) => {
+        server.once('error', reject);
+        server.listen(port, '127.0.0.1', done);
+    });
+    return server;
+}

package/dist/sessions.js

@@ -0,0 +1,302 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+import { mkdir, readFile, readdir, rename, stat, unlink, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join, isAbsolute, relative, resolve } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { adapters } from './adapters.js';
+const sessionDirectory = join(homedir(), '.agent-muster', 'sessions');
+const legacyDataFile = join(homedir(), '.agent-muster', 'sessions.json');
+function sessionFile(id) {
+    return join(sessionDirectory, `${encodeURIComponent(id)}.json`);
+}
+async function writeSession(id, snapshot) {
+    await mkdir(sessionDirectory, { recursive: true });
+    const file = sessionFile(id);
+    const temporary = `${file}.${process.pid}.tmp`;
+    await writeFile(temporary, snapshot);
+    await rename(temporary, file);
+}
+function isWarning(text) {
+    return text.trim().split(/\r?\n/).every(line => /^\S+\s+WARN\b/.test(line));
+}
+function fileDiff(cwd, path) {
+    const file = resolve(cwd, path);
+    const localPath = relative(cwd, file);
+    if (localPath.startsWith('..') || isAbsolute(localPath))
+        return undefined;
+    const repository = spawnSync('git', ['-C', cwd, 'rev-parse', '--is-inside-work-tree'], { encoding: 'utf8', timeout: 2000 });
+    if (repository.status !== 0 || repository.stdout.trim() !== 'true')
+        return undefined;
+    const tracked = spawnSync('git', ['-C', cwd, 'ls-files', '--error-unmatch', '--', localPath], { encoding: 'utf8', timeout: 2000 });
+    const args = tracked.status === 0
+        ? ['-C', cwd, 'diff', '--no-ext-diff', 'HEAD', '--', localPath]
+        : ['-C', cwd, 'diff', '--no-ext-diff', '--no-index', '--', process.platform === 'win32' ? 'NUL' : '/dev/null', file];
+    const result = spawnSync('git', args, { encoding: 'utf8', timeout: 2000, maxBuffer: 1_000_000 });
+    return result.error ? undefined : result.stdout?.trim() || undefined;
+}
+export class SessionManager extends EventEmitter {
+    sessions = new Map();
+    processes = new Map();
+    writeQueue = Promise.resolve();
+    async load() {
+        const restore = (session) => {
+            if (session.status === 'running' || session.status === 'starting') {
+                session.status = 'stopped';
+                session.pid = undefined;
+            }
+            session.events ||= [];
+            for (const event of session.events) {
+                if (event.type === 'error' && isWarning(event.text))
+                    event.type = 'warning';
+            }
+            this.sessions.set(session.id, session);
+        };
+        try {
+            const files = await readdir(sessionDirectory);
+            for (const file of files.filter(name => name.endsWith('.json'))) {
+                restore(JSON.parse(await readFile(join(sessionDirectory, file), 'utf8')));
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        try {
+            const stored = JSON.parse(await readFile(legacyDataFile, 'utf8'));
+            for (const session of stored) {
+                const existing = this.sessions.get(session.id);
+                if (existing && existing.updatedAt >= session.updatedAt)
+                    continue;
+                restore(session);
+                await writeSession(session.id, JSON.stringify(session));
+            }
+            await rename(legacyDataFile, `${legacyDataFile}.${Date.now()}.bak`);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+    }
+    list() {
+        return [...this.sessions.values()].sort((a, b) => b.updatedAt - a.updatedAt);
+    }
+    get(id) {
+        return this.sessions.get(id);
+    }
+    linkDingTalkSession(id, appId) {
+        const session = this.sessions.get(id);
+        if (!session || session.dingtalkAppId === appId)
+            return;
+        session.dingtalkAppId = appId;
+        this.save(session);
+    }
+    isRunning(id) {
+        return this.processes.has(id);
+    }
+    save(session) {
+        const snapshot = JSON.stringify(session);
+        this.writeQueue = this.writeQueue.then(() => writeSession(session.id, snapshot))
+            .catch(error => console.error('Failed to save session:', error));
+    }
+    append(session, type, text, detail, kind, comparison, dingtalkConversation) {
+        const event = {
+            id: (session.events.at(-1)?.id || 0) + 1,
+            type,
+            text: text.slice(0, 50000),
+            ...(detail === undefined ? {} : { detail: detail.slice(0, 50000) }),
+            ...(kind === undefined ? {} : { kind }),
+            ...(comparison === undefined ? {} : { comparison }),
+            timestamp: Date.now(),
+            ...(dingtalkConversation ? { dingtalkConversation } : {}),
+        };
+        session.events.push(event);
+        if (session.events.length > 500)
+            session.events.splice(0, session.events.length - 500);
+        session.updatedAt = event.timestamp;
+        this.emit(session.id, event);
+        this.save(session);
+    }
+    status(session, status) {
+        session.status = status;
+        this.append(session, 'status', status);
+    }
+    addUsage(session, usage, total = false) {
+        session.usage = total ? usage : {
+            inputTokens: (session.usage?.inputTokens || 0) + usage.inputTokens,
+            outputTokens: (session.usage?.outputTokens || 0) + usage.outputTokens,
+        };
+        this.append(session, 'usage', JSON.stringify(session.usage));
+    }
+    async create(agent, cwd, prompt, model, dingtalkAppId, dingtalkConversation, images) {
+        if (!adapters[agent])
+            throw new Error('Unsupported agent');
+        if (!prompt.trim())
+            throw new Error('Prompt is required');
+        if (!isAbsolute(cwd) || !(await stat(cwd).then(value => value.isDirectory()).catch(() => false))) {
+            throw new Error('Project directory must be an existing absolute path');
+        }
+        const now = Date.now();
+        const session = {
+            id: `ses_${randomUUID()}`,
+            agent,
+            ...(dingtalkAppId ? { dingtalkAppId } : {}),
+            ...(dingtalkConversation ? { dingtalkConversation } : {}),
+            model,
+            cwd: resolve(cwd),
+            prompt: prompt.trim(),
+            status: 'starting',
+            createdAt: now,
+            updatedAt: now,
+            events: [],
+        };
+        this.sessions.set(session.id, session);
+        this.append(session, 'message', session.prompt, undefined, undefined, undefined, dingtalkConversation);
+        this.start(session, session.prompt, images);
+        return session;
+    }
+    send(id, message, model, dingtalkConversation, images) {
+        const session = this.sessions.get(id);
+        if (!session)
+            throw new Error('Session not found');
+        if (!message.trim())
+            throw new Error('Message is required');
+        if (this.processes.has(id))
+            throw new Error('Wait for the current task to finish or stop it');
+        if (!session.externalSessionId)
+            throw new Error('This agent did not create a resumable session');
+        if (model !== undefined)
+            session.model = model || undefined;
+        if (dingtalkConversation)
+            session.dingtalkConversation = dingtalkConversation;
+        this.append(session, 'message', message.trim(), undefined, undefined, undefined, dingtalkConversation);
+        this.start(session, message.trim(), images);
+        return session;
+    }
+    recordDingTalkMessage(id, content) {
+        const session = this.sessions.get(id);
+        if (!session)
+            throw new Error('Session not found');
+        this.append(session, 'dingtalk_message', content);
+        return session;
+    }
+    stop(id) {
+        const session = this.sessions.get(id);
+        if (!session)
+            throw new Error('Session not found');
+        const child = this.processes.get(id);
+        if (!child)
+            throw new Error('Session is not running');
+        this.status(session, 'stopped');
+        if (process.platform === 'win32')
+            child.kill('SIGTERM');
+        else if (child.pid)
+            process.kill(-child.pid, 'SIGTERM');
+        return session;
+    }
+    async remove(id) {
+        if (!this.sessions.has(id))
+            throw new Error('Session not found');
+        const child = this.processes.get(id);
+        if (child) {
+            const closed = new Promise(resolve => child.once('close', () => resolve()));
+            this.stop(id);
+            await closed;
+        }
+        await this.writeQueue;
+        await unlink(sessionFile(id));
+        this.sessions.delete(id);
+    }
+    shutdown() {
+        for (const id of this.processes.keys())
+            this.stop(id);
+    }
+    start(session, prompt, images) {
+        const adapter = adapters[session.agent];
+        const launch = adapter.launch(prompt, session.externalSessionId, session.model, images);
+        const child = spawn(launch.command, launch.args, {
+            cwd: session.cwd,
+            stdio: 'pipe',
+            detached: process.platform !== 'win32',
+            env: process.env,
+        });
+        this.processes.set(session.id, child);
+        session.pid = child.pid;
+        this.status(session, 'running');
+        child.stdin.end(launch.prompt === undefined ? undefined : `${launch.prompt}\n`);
+        let pending = '';
+        let stderrPending = '';
+        let failed = false;
+        const recordStderr = (line) => {
+            if (line.trim())
+                this.append(session, isWarning(line) ? 'warning' : 'error', line);
+        };
+        child.stdout.on('data', (chunk) => {
+            pending += chunk.toString('utf8');
+            const lines = pending.split('\n');
+            pending = lines.pop() || '';
+            for (const line of lines) {
+                const result = adapter.read(line.trim());
+                if (result.externalSessionId) {
+                    session.externalSessionId = result.externalSessionId;
+                    this.save(session);
+                }
+                if (result.text)
+                    this.append(session, 'output', result.text);
+                if (result.usage)
+                    this.addUsage(session, result.usage, result.usageIsTotal);
+                for (const tool of result.tools || [])
+                    this.append(session, 'tool', tool.name, tool.detail);
+                for (const change of result.changes || []) {
+                    const diff = change.diff || fileDiff(session.cwd, change.path);
+                    this.append(session, 'file_change', change.path, diff, change.kind, change.diff || !diff ? undefined : 'HEAD');
+                }
+                if (result.error) {
+                    failed = true;
+                    this.append(session, 'error', result.error);
+                }
+            }
+        });
+        child.stderr.on('data', (chunk) => {
+            stderrPending += chunk.toString('utf8');
+            const lines = stderrPending.split('\n');
+            stderrPending = lines.pop() || '';
+            for (const line of lines)
+                recordStderr(line);
+        });
+        child.on('error', error => {
+            this.append(session, 'error', error.message);
+            this.processes.delete(session.id);
+            session.pid = undefined;
+            if (session.status !== 'stopped')
+                this.status(session, 'failed');
+            this.emit(`${session.id}:idle`);
+        });
+        child.on('close', code => {
+            recordStderr(stderrPending);
+            if (pending.trim()) {
+                const result = adapter.read(pending.trim());
+                if (result.text)
+                    this.append(session, 'output', result.text);
+                if (result.usage)
+                    this.addUsage(session, result.usage, result.usageIsTotal);
+                for (const tool of result.tools || [])
+                    this.append(session, 'tool', tool.name, tool.detail);
+                for (const change of result.changes || []) {
+                    const diff = change.diff || fileDiff(session.cwd, change.path);
+                    this.append(session, 'file_change', change.path, diff, change.kind, change.diff || !diff ? undefined : 'HEAD');
+                }
+                if (result.error) {
+                    failed = true;
+                    this.append(session, 'error', result.error);
+                }
+            }
+            this.processes.delete(session.id);
+            session.pid = undefined;
+            if (session.status !== 'stopped' && session.status !== 'failed') {
+                this.status(session, code === 0 && !failed ? 'completed' : 'failed');
+            }
+            this.emit(`${session.id}:idle`);
+        });
+    }
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "agent-muster",
+  "version": "0.1.0",
+  "description": "A local web interface for managing coding agents, projects, sessions, and DingTalk integrations.",
+  "author": "sexyAmole",
+  "license": "UNLICENSED",
+  "homepage": "https://github.com/sexyAmole/agent-muster",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sexyAmole/agent-muster.git"
+  },
+  "bugs": {
+    "url": "https://github.com/sexyAmole/agent-muster/issues"
+  },
+  "keywords": [
+    "cli",
+    "coding-agent",
+    "codex",
+    "claude-code",
+    "dingtalk"
+  ],
+  "type": "module",
+  "packageManager": "pnpm@10.33.4",
+  "bin": {
+    "agent-muster": "./bin/agent-muster.js"
+  },
+  "scripts": {
+    "dev": "pnpm run build && tsx watch src/cli.ts web --no-open",
+    "build": "tsc -p tsconfig.json && vite build --config web/vite.config.ts",
+    "prepack": "pnpm run build",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p web/tsconfig.json --noEmit",
+    "start": "node bin/agent-muster.js web --no-open"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "web/dist"
+  ],
+  "dependencies": {
+    "dingtalk-stream": "2.1.6-beta.1",
+    "express": "^5.1.0",
+    "qrcode": "^1.5.4",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
+    "react-markdown": "^10.1.0",
+    "remark-gfm": "^4.0.1",
+    "undici": "^8.11.2"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.2",
+    "@types/node": "^22.15.0",
+    "@types/qrcode": "^1.5.6",
+    "@types/react": "^19.1.0",
+    "@types/react-dom": "^19.1.0",
+    "@vitejs/plugin-react": "^4.7.0",
+    "tsx": "^4.20.0",
+    "typescript": "^5.8.0",
+    "vite": "^6.3.0"
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  }
+}