@geckom/opencode-queue 0.1.2

package/dist/queue-processor.js

@@ -0,0 +1,273 @@
+import { existsSync, readFileSync } from "fs";
+import { LAST_ACTIVITY_FILE, LOCK_FILE, PROCESSING_LOCK_REFRESH_MS, PROCESSING_LOCK_STALE_MS } from "./constants.js";
+import { BlockWatcher } from "./block-watcher.js";
+import { FileLock } from "./file-lock.js";
+import { IdleDetector } from "./idle-detector.js";
+import { QueueManager } from "./queue-manager.js";
+import { sleep } from "./utils.js";
+/**
+ * QueueProcessor is the state machine executor. It owns session creation,
+ * completion polling, and retry transitions for a single coordinator.
+ */
+export class QueueProcessor {
+    isProcessing = false;
+    blockWatcher;
+    queueManager;
+    client;
+    idleDetector;
+    serverUrl;
+    constructor(queueManager, client, idleDetector, serverUrl) {
+        this.queueManager = queueManager;
+        this.client = client;
+        this.idleDetector = idleDetector;
+        this.serverUrl = serverUrl;
+        this.blockWatcher = new BlockWatcher(queueManager, client);
+    }
+    async processNext() {
+        if (!(await FileLock.acquire(LOCK_FILE, PROCESSING_LOCK_STALE_MS)))
+            return false;
+        const heartbeat = FileLock.startHeartbeat(LOCK_FILE, PROCESSING_LOCK_REFRESH_MS);
+        try {
+            const result = await this.processNextLocked();
+            return result.processed;
+        }
+        finally {
+            FileLock.stopHeartbeat(heartbeat);
+            FileLock.release(LOCK_FILE);
+        }
+    }
+    async processNextLocked() {
+        if (this.isProcessing)
+            return { processed: false, continueQueue: false };
+        const item = await this.queueManager.getNextPending();
+        if (!item)
+            return { processed: false, continueQueue: false };
+        this.isProcessing = true;
+        try {
+            if (!existsSync(item.workspace)) {
+                await this.queueManager.updateItem(item.id, {
+                    status: "failed",
+                    error: `Directory not found: ${item.workspace}`,
+                    completedAt: new Date().toISOString(),
+                });
+                this.isProcessing = false;
+                return { processed: true, continueQueue: true };
+            }
+            const q = { directory: item.workspace };
+            const isFollowup = Boolean(item.followupMessage) && Boolean(item.sessionId);
+            let sessionId = item.sessionId;
+            if (!sessionId) {
+                const { data: session } = await this.client.session.create({
+                    query: q,
+                    body: { title: item.goal.substring(0, 100) },
+                });
+                if (!session) {
+                    await this.queueManager.updateItem(item.id, {
+                        status: "failed",
+                        error: "Failed to create session",
+                    });
+                    this.isProcessing = false;
+                    return { processed: true, continueQueue: true };
+                }
+                sessionId = session.id;
+                await this.queueManager.updateItem(item.id, {
+                    sessionId: session.id,
+                    sessionUrl: new URL(`/session/${session.id}`, this.serverUrl).toString(),
+                    startedAt: new Date().toISOString(),
+                    status: "running",
+                    nextRetryAt: null,
+                    error: null,
+                });
+            }
+            else {
+                await this.queueManager.updateItem(item.id, {
+                    status: "running",
+                    nextRetryAt: null,
+                    error: null,
+                    ...(isFollowup ? { followupMessage: null } : {}),
+                });
+            }
+            if (isFollowup) {
+                await this.queueManager.markDescendantsStale(item.id);
+            }
+            await this.client.session.promptAsync({
+                path: { id: sessionId },
+                query: q,
+                body: {
+                    parts: [{ type: "text", text: isFollowup ? item.followupMessage : item.goal }],
+                },
+            });
+            await this.waitForCompletion(item.id, sessionId, q);
+            const current = this.queueManager.getItem(item.id);
+            return { processed: true, continueQueue: current?.status !== "blocked" };
+        }
+        catch (err) {
+            await this.handleSessionError(item.id, err);
+            return { processed: true, continueQueue: true };
+        }
+        finally {
+            this.isProcessing = false;
+        }
+    }
+    async continueSession(itemId, sessionId, workspace) {
+        const deadline = Date.now() + this.queueManager.getConfig().sessionTimeoutMinutes * 60 * 1000;
+        while (!(await FileLock.acquire(LOCK_FILE, PROCESSING_LOCK_STALE_MS))) {
+            if (Date.now() >= deadline)
+                return;
+            await sleep(1_000);
+        }
+        const heartbeat = FileLock.startHeartbeat(LOCK_FILE, PROCESSING_LOCK_REFRESH_MS);
+        try {
+            await this.waitForCompletion(itemId, sessionId, { directory: workspace });
+        }
+        finally {
+            FileLock.stopHeartbeat(heartbeat);
+            FileLock.release(LOCK_FILE);
+        }
+    }
+    async waitForCompletion(itemId, sessionId, q) {
+        try {
+            const maxWaitMs = this.queueManager.getConfig().sessionTimeoutMinutes * 60 * 1000;
+            const pollIntervalMs = 5_000;
+            const startTime = Date.now();
+            while (Date.now() - startTime < maxWaitMs) {
+                const item = this.queueManager.getItem(itemId);
+                if (!item)
+                    return;
+                const blocked = await this.blockWatcher.checkForBlocks(item);
+                if (blocked)
+                    return;
+                const { data: statusMap } = await this.client.session.status({ query: q });
+                if (statusMap && statusMap[sessionId]) {
+                    const status = statusMap[sessionId];
+                    if (status.type === "idle") {
+                        await this.captureResult(itemId, sessionId, q);
+                        return;
+                    }
+                    if (status.type === "retry" && status.next) {
+                        await new Promise((resolve) => setTimeout(resolve, Math.min(status.next - Date.now(), pollIntervalMs)));
+                        continue;
+                    }
+                }
+                else if (statusMap && !statusMap[sessionId]) {
+                    const { data: messages } = await this.client.session.messages({
+                        path: { id: sessionId },
+                        query: q,
+                    });
+                    const hasAssistantMessage = Boolean(messages?.some((message) => message.info.role === "assistant"));
+                    if (hasAssistantMessage) {
+                        await this.captureResult(itemId, sessionId, q);
+                        return;
+                    }
+                }
+                await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+            }
+            await this.queueManager.updateItem(itemId, {
+                status: "failed",
+                error: "Session timed out",
+                completedAt: new Date().toISOString(),
+            });
+        }
+        catch (err) {
+            await this.queueManager.updateItem(itemId, {
+                status: "failed",
+                error: err instanceof Error ? err.message : String(err),
+                completedAt: new Date().toISOString(),
+            });
+        }
+    }
+    async captureResult(itemId, sessionId, q) {
+        try {
+            const { data: messages } = await this.client.session.messages({
+                path: { id: sessionId },
+                query: q,
+            });
+            let result = "Task completed";
+            if (messages && messages.length > 0) {
+                const lastAssistant = [...messages].reverse().find((message) => message.info.role === "assistant");
+                if (lastAssistant) {
+                    const textParts = lastAssistant.parts.filter((part) => part.type === "text");
+                    if (textParts.length > 0) {
+                        result = textParts.map((part) => part.text).join("\n").substring(0, 1000);
+                    }
+                }
+            }
+            await this.queueManager.updateItem(itemId, {
+                status: "review_pending",
+                result,
+                completedAt: null,
+                reviewedAt: null,
+                retryCount: 0,
+                nextRetryAt: null,
+                error: null,
+            });
+        }
+        catch {
+            await this.queueManager.updateItem(itemId, {
+                status: "review_pending",
+                result: "Task completed (could not fetch result)",
+                completedAt: null,
+                reviewedAt: null,
+                retryCount: 0,
+                nextRetryAt: null,
+                error: null,
+            });
+        }
+    }
+    async handleSessionError(itemId, err) {
+        const item = this.queueManager.getItem(itemId);
+        if (!item)
+            return;
+        const config = this.queueManager.getConfig();
+        const newRetryCount = item.retryCount + 1;
+        if (newRetryCount >= config.maxRetries) {
+            await this.queueManager.updateItem(itemId, {
+                status: "failed",
+                error: err instanceof Error ? err.message : String(err),
+                retryCount: newRetryCount,
+                completedAt: new Date().toISOString(),
+            });
+            return;
+        }
+        const delayMinutes = config.retryDelaysMinutes[newRetryCount - 1] || 15;
+        await this.queueManager.updateItem(itemId, {
+            status: "pending",
+            retryCount: newRetryCount,
+            nextRetryAt: new Date(Date.now() + delayMinutes * 60 * 1000).toISOString(),
+            error: err instanceof Error ? err.message : String(err),
+        });
+    }
+    async processQueue() {
+        if (!(await FileLock.acquire(LOCK_FILE, PROCESSING_LOCK_STALE_MS)))
+            return;
+        const heartbeat = FileLock.startHeartbeat(LOCK_FILE, PROCESSING_LOCK_REFRESH_MS);
+        try {
+            let hasMore = true;
+            while (hasMore) {
+                const result = await this.processNextLocked();
+                if (!result.processed || !result.continueQueue) {
+                    hasMore = false;
+                    continue;
+                }
+                const lastActivity = (() => {
+                    try {
+                        return Number.parseInt(readFileSync(LAST_ACTIVITY_FILE, "utf-8").trim(), 10);
+                    }
+                    catch {
+                        return 0;
+                    }
+                })();
+                const stillIdle = Date.now() - lastActivity >= this.queueManager.getConfig().idleTimeoutSeconds * 1000;
+                if (!stillIdle)
+                    hasMore = false;
+            }
+        }
+        finally {
+            FileLock.stopHeartbeat(heartbeat);
+            FileLock.release(LOCK_FILE);
+        }
+    }
+    getBlockWatcher() {
+        return this.blockWatcher;
+    }
+}

package/dist/schedule-manager.js

@@ -0,0 +1,126 @@
+import { CronJob } from "cron";
+/**
+ * ScheduleManager is responsible only for CronJob lifecycle and translating
+ * schedule triggers into queue items via QueueManager APIs.
+ */
+export class ScheduleManager {
+    queueManager;
+    jobs = new Map();
+    constructor(queueManager) {
+        this.queueManager = queueManager;
+    }
+    createJob(schedule, onFire) {
+        return new CronJob(schedule.scheduledFor ? new Date(schedule.scheduledFor) : schedule.cronExpression, onFire, undefined, true, schedule.timezone, null, false, null, true);
+    }
+    start() {
+        const schedules = this.queueManager.listSchedules();
+        for (const schedule of schedules) {
+            if (schedule.enabled)
+                this.startJob(schedule);
+        }
+    }
+    stop() {
+        for (const [id, job] of this.jobs) {
+            job.stop();
+            this.jobs.delete(id);
+        }
+    }
+    startJob(schedule) {
+        if (this.jobs.has(schedule.id)) {
+            this.jobs.get(schedule.id).stop();
+        }
+        const onFire = () => void this.onTrigger(schedule.id);
+        if (schedule.scheduledFor) {
+            const fireDate = new Date(schedule.scheduledFor);
+            if (Number.isNaN(fireDate.getTime()))
+                return;
+            if (fireDate.getTime() <= Date.now()) {
+                void this.onTrigger(schedule.id);
+                return;
+            }
+            const job = this.createJob(schedule, onFire);
+            this.jobs.set(schedule.id, job);
+            return;
+        }
+        if (schedule.cronExpression) {
+            try {
+                const job = this.createJob(schedule, onFire);
+                this.jobs.set(schedule.id, job);
+            }
+            catch {
+                // Invalid cron expression. Leave the persisted schedule untouched.
+            }
+        }
+    }
+    async onTrigger(scheduleId) {
+        const result = await this.queueManager.triggerSchedule(scheduleId);
+        if (!result)
+            return;
+        if (!result.schedule.enabled && this.jobs.has(scheduleId)) {
+            this.jobs.get(scheduleId).stop();
+            this.jobs.delete(scheduleId);
+        }
+    }
+    async addAndStart(schedule) {
+        const task = await this.queueManager.addSchedule(schedule);
+        if (task.cronExpression) {
+            try {
+                const job = new CronJob(task.cronExpression, () => { }, undefined, false, task.timezone);
+                const nextDate = job.nextDate();
+                await this.queueManager.updateSchedule(task.id, {
+                    nextTriggerAt: nextDate ? nextDate.toISO() : null,
+                });
+                job.stop();
+            }
+            catch { }
+        }
+        else if (task.scheduledFor) {
+            await this.queueManager.updateSchedule(task.id, { nextTriggerAt: task.scheduledFor });
+        }
+        const updated = this.queueManager.getSchedule(task.id);
+        if (updated.enabled)
+            this.startJob(updated);
+        return updated;
+    }
+    async removeAndStop(id) {
+        const job = this.jobs.get(id);
+        if (job) {
+            job.stop();
+            this.jobs.delete(id);
+        }
+        return this.queueManager.removeSchedule(id);
+    }
+    async pause(id) {
+        const job = this.jobs.get(id);
+        if (job) {
+            job.stop();
+            this.jobs.delete(id);
+        }
+        return this.queueManager.updateSchedule(id, { enabled: false, nextTriggerAt: null });
+    }
+    async resume(id) {
+        const updated = await this.queueManager.updateSchedule(id, { enabled: true });
+        if (!updated)
+            return updated;
+        if (updated.cronExpression) {
+            try {
+                const job = new CronJob(updated.cronExpression, () => { }, undefined, false, updated.timezone);
+                const nextDate = job.nextDate();
+                job.stop();
+                await this.queueManager.updateSchedule(updated.id, {
+                    nextTriggerAt: nextDate ? nextDate.toISO() : null,
+                });
+            }
+            catch {
+                await this.queueManager.updateSchedule(updated.id, { nextTriggerAt: null });
+            }
+        }
+        else if (updated.scheduledFor) {
+            await this.queueManager.updateSchedule(updated.id, { nextTriggerAt: updated.scheduledFor });
+        }
+        const resumed = this.queueManager.getSchedule(updated.id);
+        if (resumed)
+            this.startJob(resumed);
+        return resumed;
+    }
+}

package/dist/session-greeter.js

@@ -0,0 +1,81 @@
+import { QueueManager } from "./queue-manager.js";
+import { safeToast } from "./toast.js";
+export class SessionGreeter {
+    messageCounts = new Map();
+    blockedReminderTimer = null;
+    lastBlockedReminderAt = 0;
+    getConfig;
+    queueManager;
+    client;
+    constructor(getConfig, queueManager, client) {
+        this.getConfig = getConfig;
+        this.queueManager = queueManager;
+        this.client = client;
+    }
+    async onSessionCreated() {
+        this.showToast();
+    }
+    startBlockedReminders() {
+        if (this.blockedReminderTimer)
+            return;
+        this.blockedReminderTimer = setInterval(() => {
+            void this.checkBlockedReminder();
+        }, 60_000);
+        this.blockedReminderTimer.unref?.();
+    }
+    stop() {
+        if (this.blockedReminderTimer) {
+            clearInterval(this.blockedReminderTimer);
+            this.blockedReminderTimer = null;
+        }
+    }
+    async onMessageUpdated(sessionId) {
+        const count = (this.messageCounts.get(sessionId) || 0) + 1;
+        this.messageCounts.set(sessionId, count);
+        if (count >= this.getConfig().reminderIntervalMessages) {
+            this.messageCounts.set(sessionId, 0);
+            this.showToast();
+        }
+    }
+    async checkBlockedReminder() {
+        const blockedItems = this.queueManager.listItems("blocked");
+        if (blockedItems.length === 0) {
+            this.lastBlockedReminderAt = 0;
+            return;
+        }
+        const intervalMs = this.getConfig().blockedReminderMinutes * 60 * 1000;
+        if (intervalMs > 0 && Date.now() - this.lastBlockedReminderAt < intervalMs) {
+            return;
+        }
+        const first = blockedItems[0];
+        const summary = first.blockedReason?.details || first.goal;
+        this.lastBlockedReminderAt = Date.now();
+        safeToast(this.client, `Queue blocked: ${blockedItems.length} item${blockedItems.length === 1 ? "" : "s"} waiting. ${summary.substring(0, 120)}`, "warning");
+    }
+    showToast() {
+        const counts = this.queueManager.countByStatus();
+        const pending = counts.pending || 0;
+        const blocked = counts.blocked || 0;
+        const reviewPending = counts.review_pending || 0;
+        const completed = counts.completed || 0;
+        const running = counts.running || 0;
+        const failed = counts.failed || 0;
+        const total = pending + blocked + reviewPending + completed + running + failed;
+        if (total === 0)
+            return;
+        const parts = [];
+        if (pending > 0)
+            parts.push(`${pending} pending`);
+        if (blocked > 0)
+            parts.push(`${blocked} blocked`);
+        if (reviewPending > 0)
+            parts.push(`${reviewPending} review`);
+        if (running > 0)
+            parts.push(`${running} running`);
+        if (completed > 0)
+            parts.push(`${completed} completed`);
+        if (failed > 0)
+            parts.push(`${failed} failed`);
+        safeToast(this.client, `Queue: ${parts.join(", ")}`, blocked > 0 ? "warning" : "info");
+    }
+}

package/dist/shared-state.js

@@ -0,0 +1,105 @@
+import { existsSync, watch } from "fs";
+import { LOCK_FILE, QUEUE_FILE, SIGNAL_EXIT_CODE } from "./constants.js";
+import { FileLock } from "./file-lock.js";
+import { IdleDetector } from "./idle-detector.js";
+import { QueueProcessor } from "./queue-processor.js";
+import { QueueManager } from "./queue-manager.js";
+import { ScheduleManager } from "./schedule-manager.js";
+import { SessionGreeter } from "./session-greeter.js";
+const SHARED_STATE_KEY = Symbol.for("opencode.queue.shared-state");
+let activeFsWatcher;
+export function createSharedState(client, serverUrl) {
+    const queueManager = new QueueManager();
+    const idleDetector = new IdleDetector(() => queueManager.getConfig(), async () => {
+        const processor = new QueueProcessor(queueManager, client, idleDetector, serverUrl);
+        await processor.processQueue();
+    });
+    const scheduleManager = new ScheduleManager(queueManager);
+    const sessionGreeter = new SessionGreeter(() => queueManager.getConfig(), queueManager, client);
+    let fsWatchTimer;
+    try {
+        if (existsSync(QUEUE_FILE)) {
+            activeFsWatcher = watch(QUEUE_FILE, () => {
+                if (fsWatchTimer)
+                    clearTimeout(fsWatchTimer);
+                fsWatchTimer = setTimeout(() => {
+                    fsWatchTimer = undefined;
+                    const processor = new QueueProcessor(queueManager, client, idleDetector, serverUrl);
+                    void processor.processQueue();
+                }, 500);
+                fsWatchTimer.unref?.();
+            });
+            activeFsWatcher.unref?.();
+        }
+    }
+    catch { }
+    return {
+        queueManager,
+        idleDetector,
+        scheduleManager,
+        sessionGreeter,
+        coordinatorClaimed: false,
+        initialized: queueManager.resetRunningToPending(),
+        cleanupHandlers: [],
+        cleanedUp: false,
+    };
+}
+export function cleanupSharedState(shared) {
+    if (shared.cleanedUp)
+        return;
+    shared.cleanedUp = true;
+    shared.scheduleManager.stop();
+    shared.idleDetector.stop();
+    shared.sessionGreeter.stop();
+    try {
+        activeFsWatcher?.close();
+    }
+    catch { }
+    activeFsWatcher = undefined;
+    FileLock.release(LOCK_FILE);
+}
+export function registerProcessCleanup(shared) {
+    if (shared.cleanupHandlers.length > 0)
+        return;
+    const onExit = () => {
+        cleanupSharedState(shared);
+    };
+    const onBeforeExit = () => {
+        cleanupSharedState(shared);
+    };
+    const registerSignalHandler = (signal) => {
+        const handler = () => {
+            cleanupSharedState(shared);
+            process.exit(SIGNAL_EXIT_CODE[signal] ?? 0);
+        };
+        process.once(signal, handler);
+        shared.cleanupHandlers.push({ event: signal, handler });
+    };
+    process.once("exit", onExit);
+    shared.cleanupHandlers.push({ event: "exit", handler: onExit });
+    process.once("beforeExit", onBeforeExit);
+    shared.cleanupHandlers.push({ event: "beforeExit", handler: onBeforeExit });
+    registerSignalHandler("SIGINT");
+    registerSignalHandler("SIGTERM");
+}
+export function unregisterProcessCleanup(shared) {
+    for (const { event, handler } of shared.cleanupHandlers) {
+        process.removeListener(event, handler);
+    }
+    shared.cleanupHandlers = [];
+}
+export function getSharedState(client, serverUrl) {
+    const globalState = globalThis;
+    if (!globalState[SHARED_STATE_KEY]) {
+        globalState[SHARED_STATE_KEY] = createSharedState(client, serverUrl);
+    }
+    return globalState[SHARED_STATE_KEY];
+}
+export function resetSharedState() {
+    const globalState = globalThis;
+    if (globalState[SHARED_STATE_KEY]) {
+        unregisterProcessCleanup(globalState[SHARED_STATE_KEY]);
+        cleanupSharedState(globalState[SHARED_STATE_KEY]);
+    }
+    delete globalState[SHARED_STATE_KEY];
+}

package/dist/toast.js

@@ -0,0 +1,11 @@
+export function safeToast(client, message, variant, duration) {
+    void client.tui
+        .showToast({
+        body: {
+            message,
+            variant,
+            duration,
+        },
+    })
+        .catch(() => { });
+}

package/dist/types.js

@@ -0,0 +1,5 @@
+/**
+ * Core queue domain types shared across the plugin runtime and tests.
+ * Keep status and dependency unions centralized so behavior stays explicit.
+ */
+export {};

package/dist/utils.js

@@ -0,0 +1,29 @@
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export function createQueueItemFromSchedule(schedule, scheduleId) {
+    return {
+        id: crypto.randomUUID(),
+        workspace: schedule.workspace,
+        goal: schedule.goal,
+        status: "pending",
+        parentItemId: schedule.parentItemId,
+        dependencyMode: schedule.dependencyMode,
+        dependencySatisfiedAt: null,
+        dependencySourceStatus: null,
+        dependencyBlockedReason: schedule.parentItemId ? `Waiting for parent ${schedule.parentItemId} to start.` : null,
+        staleDependency: false,
+        sessionId: null,
+        createdAt: new Date().toISOString(),
+        startedAt: null,
+        completedAt: null,
+        reviewedAt: null,
+        blockedReason: null,
+        error: null,
+        result: null,
+        sessionUrl: null,
+        retryCount: 0,
+        nextRetryAt: null,
+        sourceScheduleId: scheduleId,
+    };
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@geckom/opencode-queue",
+  "version": "0.1.2",
+  "description": "OpenCode plugin that maintains a global task queue and processes queued work when OpenCode is idle.",
+  "author": "Geckom",
+  "license": "MIT",
+  "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
+  "main": "./dist/opencode-queue.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/geckom/opencode-queue.git"
+  },
+  "bugs": {
+    "url": "https://github.com/geckom/opencode-queue/issues"
+  },
+  "homepage": "https://github.com/geckom/opencode-queue#readme",
+  "exports": {
+    ".": {
+      "import": "./dist/opencode-queue.js"
+    }
+  },
+  "files": [
+    "dist/*.js",
+    "!dist/testing.js",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "queue",
+    "automation"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.json",
+    "bundle": "esbuild src/opencode-queue.ts --bundle --platform=node --format=esm --external:@opencode-ai/* --outfile=dist/opencode-queue.bundled.js",
+    "build:runtime": "npm run build && npm run bundle && mkdir -p \"$HOME/.config/opencode/plugins\" && cp dist/opencode-queue.bundled.js \"$HOME/.config/opencode/plugins/opencode-queue.js\"",
+    "pack:check": "npm pack --dry-run",
+    "prepublishOnly": "npm test && npm run build",
+    "test": "node --test test/*.test.mjs"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "1.15.0",
+    "@opencode-ai/sdk": "1.15.0",
+    "cron": "^4.4.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.12.4",
+    "esbuild": "^0.28.0",
+    "typescript": "^5.9.3"
+  }
+}