parallel-codex-tui 0.1.0

package/dist/workers/mock-adapter.js

@@ -0,0 +1,62 @@
+import { join } from "node:path";
+import { appendText, readTextIfExists, writeJson, writeText } from "../core/file-store.js";
+export class MockWorkerAdapter {
+    name = "mock";
+    async run(spec) {
+        const nativeSessionId = spec.nativeSession?.session_id ?? `mock-${spec.workerId}`;
+        await spec.onNativeSession?.(nativeSessionId);
+        await setStatus(spec, "running", "mock-running", `${spec.role} mock worker running`, nativeSessionId);
+        await appendText(spec.outputLogPath, `[mock:${spec.role}] started\n`);
+        if (spec.role === "judge") {
+            await writeText(join(spec.filesDir, "requirements.md"), "# Requirements\n\n- Mock requirements derived from the user request.\n");
+            await writeText(join(spec.filesDir, "plan.md"), "# Plan\n\n1. Run Actor.\n2. Run Critic.\n");
+            await writeText(join(spec.filesDir, "acceptance.md"), "# Acceptance\n\n- Mock review approves the result.\n");
+            await writeText(join(spec.filesDir, "actor-brief.md"), "# Actor Brief\n\nImplement the requested change and write a worklog.\n");
+            await writeText(join(spec.filesDir, "critic-brief.md"), "# Critic Brief\n\nReview the Actor output against acceptance criteria.\n");
+        }
+        if (spec.role === "actor") {
+            await writeText(join(spec.filesDir, "worklog.md"), "# Worklog\n\n- Mock actor completed the implementation.\n");
+            await writeText(join(spec.filesDir, "patch.diff"), "diff --git a/mock b/mock\n");
+            const featureDir = featureDirFromPrompt(spec.prompt);
+            if (featureDir) {
+                await writeText(join(featureDir, "actor-worklog.md"), "# Worklog\n\n- Mock actor completed the implementation.\n");
+            }
+        }
+        if (spec.role === "critic") {
+            await writeText(join(spec.filesDir, "review.md"), "# Review\n\nAPPROVED\n\nNo blocking findings in mock review.\n");
+            const featureDir = featureDirFromPrompt(spec.prompt);
+            if (featureDir) {
+                const findingsPath = join(featureDir, "critic-findings.jsonl");
+                if (!(await readTextIfExists(findingsPath)).trim()) {
+                    await writeText(findingsPath, "");
+                }
+            }
+        }
+        if (spec.role === "main") {
+            await appendText(spec.outputLogPath, `Mock simple response for: ${spec.prompt.trim()}\n`);
+        }
+        await appendText(spec.outputLogPath, `[mock:${spec.role}] done\n`);
+        await setStatus(spec, "done", "mock-done", `${spec.role} mock worker done`, nativeSessionId);
+        return {
+            workerId: spec.workerId,
+            exitCode: 0,
+            signal: null
+        };
+    }
+}
+function featureDirFromPrompt(prompt) {
+    const line = prompt.split("\n").find((item) => item.startsWith("Feature directory: "));
+    return line ? line.replace("Feature directory: ", "").trim() : null;
+}
+async function setStatus(spec, state, phase, summary, nativeSessionId) {
+    await writeJson(spec.statusPath, {
+        worker_id: spec.workerId,
+        role: spec.role,
+        engine: spec.engine,
+        state,
+        phase,
+        last_event_at: new Date().toISOString(),
+        summary,
+        ...(nativeSessionId ? { native_session_id: nativeSessionId } : {})
+    });
+}

package/dist/workers/native-attach.js

@@ -0,0 +1,189 @@
+import { accessSync, chmodSync, constants, existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { readdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { spawn } from "node-pty";
+import { pathExists, readJson, readTextIfExists, writeJson } from "../core/file-store.js";
+import { NativeSessionSchema, TaskMetaSchema } from "../domain/schemas.js";
+const require = createRequire(import.meta.url);
+export async function buildNativeAttachLaunch(input) {
+    const nativeSession = await readWorkerNativeSession(input.worker);
+    const workerConfig = input.config.workers[input.worker.engine];
+    const modelConfig = workerConfig.model;
+    return {
+        command: workerConfig.interactive.command,
+        args: workerConfig.interactive.args.map((arg) => renderTemplate(arg, nativeSession.session_id, modelConfig)),
+        cwd: nativeSession.cwd,
+        sessionId: nativeSession.session_id,
+        label: input.worker.label
+    };
+}
+export function startNativeAttachProcess(launch, handlers = {}) {
+    ensureNodePtySpawnHelperExecutable();
+    const child = spawn(launch.command, launch.args, {
+        name: "xterm-256color",
+        cols: launch.cols ?? process.stdout.columns ?? 120,
+        rows: launch.rows ?? process.stdout.rows ?? 30,
+        cwd: launch.cwd,
+        env: {
+            ...process.env,
+            TERM: process.env.TERM || "xterm-256color"
+        }
+    });
+    child.onData((chunk) => {
+        handlers.onOutput?.(chunk);
+    });
+    child.onExit(({ exitCode }) => {
+        handlers.onClose?.(exitCode);
+    });
+    return {
+        write(input) {
+            child.write(input);
+        },
+        kill() {
+            child.kill("SIGTERM");
+        }
+    };
+}
+function ensureNodePtySpawnHelperExecutable() {
+    if (process.platform === "win32") {
+        return;
+    }
+    const packageRoot = dirname(dirname(require.resolve("node-pty")));
+    const helperPath = join(packageRoot, "prebuilds", `${process.platform}-${process.arch}`, "spawn-helper");
+    if (!existsSync(helperPath)) {
+        return;
+    }
+    try {
+        accessSync(helperPath, constants.X_OK);
+    }
+    catch {
+        chmodSync(helperPath, 0o755);
+    }
+}
+async function readWorkerNativeSession(worker) {
+    const workerDir = dirname(worker.statusPath);
+    const nativePath = join(workerDir, "native-session.json");
+    if (!(await pathExists(nativePath))) {
+        const recovered = await recoverClaudeNativeSession(worker, workerDir);
+        if (recovered) {
+            await writeJson(nativePath, NativeSessionSchema.parse(recovered));
+            return recovered;
+        }
+        throw new Error(`No native session recorded for ${worker.label}. Run the worker once before attaching, or make sure ${worker.engine} persisted a resumable session.`);
+    }
+    const record = await readJson(nativePath, NativeSessionSchema);
+    if (record.engine !== worker.engine) {
+        throw new Error(`Native session engine mismatch for ${worker.label}: expected ${worker.engine}, got ${record.engine}`);
+    }
+    return record;
+}
+async function recoverClaudeNativeSession(worker, workerDir) {
+    if (worker.engine !== "claude") {
+        return null;
+    }
+    const prompt = await readTextIfExists(join(workerDir, "prompt.md"));
+    if (!prompt.trim()) {
+        return null;
+    }
+    const taskDir = dirname(workerDir);
+    const metaPath = join(taskDir, "meta.json");
+    const cwd = (await pathExists(metaPath)) ? (await readJson(metaPath, TaskMetaSchema)).cwd : null;
+    if (!cwd) {
+        return null;
+    }
+    const match = await findClaudeProjectSession({
+        cwd,
+        prompt
+    });
+    if (!match) {
+        return null;
+    }
+    return {
+        engine: "claude",
+        role: worker.role,
+        worker_id: worker.id,
+        session_id: match.sessionId,
+        scope: "task",
+        cwd,
+        created_at: match.timestamp,
+        last_used_at: match.timestamp,
+        source: "claude-project-log"
+    };
+}
+async function findClaudeProjectSession(input) {
+    const projectDir = join(claudeProjectsDir(), claudeProjectSlug(input.cwd));
+    if (!(await pathExists(projectDir))) {
+        return null;
+    }
+    const entries = await readdir(projectDir, { withFileTypes: true });
+    const matches = [];
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith(".jsonl")) {
+            continue;
+        }
+        const candidate = await matchClaudeSessionFile(join(projectDir, entry.name), input);
+        if (candidate) {
+            matches.push(candidate);
+        }
+    }
+    return matches.sort((left, right) => left.timestamp.localeCompare(right.timestamp)).at(-1) ?? null;
+}
+async function matchClaudeSessionFile(path, input) {
+    const lines = (await readTextIfExists(path)).split(/\r?\n/).filter(Boolean);
+    for (const line of lines) {
+        const parsed = safeParseJson(line);
+        if (!parsed || typeof parsed !== "object") {
+            continue;
+        }
+        const record = parsed;
+        if (record.cwd !== input.cwd && record.type !== "queue-operation") {
+            continue;
+        }
+        if (extractClaudePrompt(record) !== input.prompt) {
+            continue;
+        }
+        const sessionId = typeof record.sessionId === "string" ? record.sessionId : null;
+        const timestamp = typeof record.timestamp === "string" ? record.timestamp : null;
+        if (sessionId && timestamp) {
+            return { sessionId, timestamp };
+        }
+    }
+    return null;
+}
+function extractClaudePrompt(record) {
+    if (typeof record.content === "string") {
+        return record.content;
+    }
+    const message = record.message;
+    if (!message || typeof message !== "object") {
+        return null;
+    }
+    const content = message.content;
+    return typeof content === "string" ? content : null;
+}
+function claudeProjectsDir() {
+    return process.env.PARALLEL_CODEX_CLAUDE_PROJECTS_DIR ?? join(homedir(), ".claude", "projects");
+}
+function claudeProjectSlug(cwd) {
+    return cwd.replace(/[^A-Za-z0-9]/g, "-");
+}
+function safeParseJson(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+}
+function renderTemplate(value, sessionId, modelConfig) {
+    return value
+        .replaceAll("{sessionId}", sessionId)
+        .replaceAll("{model}", modelConfig?.name ?? "")
+        .replaceAll("{provider}", modelConfig?.provider ?? "")
+        .replace(/\{env:([A-Za-z_][A-Za-z0-9_]*)\}/g, (_match, name) => process.env[name] ?? "");
+}
+export function supportsNativeAttach(engine) {
+    return engine === "codex" || engine === "claude" || engine === "mock";
+}

package/dist/workers/process-adapter.js

@@ -0,0 +1,265 @@
+import { spawn } from "node:child_process";
+import { appendText, writeJson } from "../core/file-store.js";
+export class ProcessWorkerAdapter {
+    name;
+    command;
+    args;
+    defaults;
+    constructor(command, args, name = "mock", defaults = {}) {
+        this.command = command;
+        this.args = args;
+        this.name = name;
+        this.defaults = defaults;
+    }
+    async run(spec) {
+        const model = spec.modelConfig ?? this.defaults.model;
+        const launch = buildLaunch(this.args, spec.nativeSession, spec.nativeSessionConfig, model);
+        const runSpec = {
+            ...spec,
+            timeoutMs: spec.timeoutMs ?? this.defaults.timeoutMs,
+            idleTimeoutMs: spec.idleTimeoutMs ?? this.defaults.idleTimeoutMs,
+            firstOutputTimeoutMs: spec.firstOutputTimeoutMs ?? this.defaults.firstOutputTimeoutMs,
+            nativeSession: launch.nativeSession,
+            modelConfig: model
+        };
+        const first = await this.runAttempt(runSpec, launch);
+        if (!shouldFallbackToNewNativeSession(first, runSpec.nativeSessionConfig)) {
+            return first.result;
+        }
+        const retiredSessionId = launch.nativeSession?.session_id;
+        if (retiredSessionId) {
+            await runSpec.onNativeSessionRetired?.(retiredSessionId, first.output);
+        }
+        await appendText(runSpec.outputLogPath, `\nNative resume for ${retiredSessionId ?? "unknown session"} is unrecoverable; starting a fresh native session.\n`);
+        const freshLaunch = buildFreshLaunch(this.args, model);
+        return (await this.runAttempt({
+            ...runSpec,
+            nativeSession: null
+        }, freshLaunch, {
+            initialNativeSessionId: undefined,
+            startPhase: "native-resume-fallback",
+            startSummary: `${this.command} starting fresh session after unrecoverable native resume`
+        })).result;
+    }
+    async runAttempt(runSpec, launch, options = {}) {
+        await setStatus(runSpec, "starting", options.startPhase ?? "process-starting", options.startSummary ?? `Starting ${this.command}`);
+        await appendText(runSpec.outputLogPath, `$ ${this.command} ${launch.args.join(" ")}\n`);
+        return new Promise((resolve, reject) => {
+            const child = spawn(this.command, launch.args, {
+                cwd: runSpec.cwd,
+                env: {
+                    ...process.env,
+                    ...buildModelEnv(runSpec.modelConfig),
+                    PARALLEL_CODEX_WORKER_ID: runSpec.workerId,
+                    PARALLEL_CODEX_ROLE: runSpec.role,
+                    PARALLEL_CODEX_FILES_DIR: runSpec.filesDir
+                },
+                stdio: ["pipe", "pipe", "pipe"]
+            });
+            let settled = false;
+            let timeout;
+            let idleTimeout;
+            let firstOutputTimeout;
+            let terminalPhase;
+            let terminalSummary;
+            let outputWrites = Promise.resolve();
+            let detectedNativeSessionId = options.initialNativeSessionId ?? runSpec.nativeSession?.session_id;
+            let sawOutput = false;
+            const outputChunks = [];
+            const finish = async (result) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                if (timeout) {
+                    clearTimeout(timeout);
+                }
+                if (idleTimeout) {
+                    clearTimeout(idleTimeout);
+                }
+                if (firstOutputTimeout) {
+                    clearTimeout(firstOutputTimeout);
+                }
+                await outputWrites;
+                const phase = terminalPhase ?? (launch.isResume && result.exitCode !== 0 ? "native-resume-failed" : "process-exited");
+                const summary = terminalSummary ??
+                    (launch.isResume && result.exitCode !== 0
+                        ? `${this.command} native resume exited with code ${result.exitCode}`
+                        : `${this.command} exited with code ${result.exitCode}`);
+                await setStatus(runSpec, result.exitCode === 0 ? "done" : "failed", phase, summary, detectedNativeSessionId);
+                resolve({
+                    result,
+                    output: outputChunks.join(""),
+                    launch
+                });
+            };
+            const resetIdleTimeout = () => {
+                if (!runSpec.idleTimeoutMs || runSpec.idleTimeoutMs <= 0 || settled) {
+                    return;
+                }
+                if (idleTimeout) {
+                    clearTimeout(idleTimeout);
+                }
+                idleTimeout = setTimeout(() => {
+                    terminalPhase = "process-idle-timeout";
+                    terminalSummary = `${this.command} produced no output for ${runSpec.idleTimeoutMs}ms`;
+                    void appendText(runSpec.outputLogPath, `\nProcess idle timed out after ${runSpec.idleTimeoutMs}ms\n`);
+                    void setStatus(runSpec, "failed", terminalPhase, terminalSummary);
+                    child.kill("SIGTERM");
+                }, runSpec.idleTimeoutMs);
+            };
+            const recordOutput = (chunk) => {
+                sawOutput = true;
+                if (firstOutputTimeout) {
+                    clearTimeout(firstOutputTimeout);
+                    firstOutputTimeout = undefined;
+                }
+                const text = chunk.toString("utf8");
+                outputChunks.push(text);
+                outputWrites = outputWrites.then(async () => {
+                    await appendText(runSpec.outputLogPath, text);
+                    const sessionId = detectNativeSessionId(text);
+                    if (sessionId && sessionId !== detectedNativeSessionId && runSpec.nativeSessionConfig?.detectSessionId !== false) {
+                        detectedNativeSessionId = sessionId;
+                        await runSpec.onNativeSession?.(sessionId);
+                    }
+                    if (!settled) {
+                        await setStatus(runSpec, "running", "process-output", summarizeOutput(text), detectedNativeSessionId);
+                    }
+                });
+                resetIdleTimeout();
+            };
+            child.stdout.on("data", (chunk) => {
+                recordOutput(chunk);
+            });
+            child.stderr.on("data", (chunk) => {
+                recordOutput(chunk);
+            });
+            child.on("error", (error) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                if (timeout) {
+                    clearTimeout(timeout);
+                }
+                if (idleTimeout) {
+                    clearTimeout(idleTimeout);
+                }
+                if (firstOutputTimeout) {
+                    clearTimeout(firstOutputTimeout);
+                }
+                void setStatus(runSpec, "failed", "process-error", error.message, detectedNativeSessionId).finally(() => reject(error));
+            });
+            child.on("close", (code, signal) => {
+                void finish({
+                    workerId: runSpec.workerId,
+                    exitCode: code ?? 1,
+                    signal
+                });
+            });
+            if (runSpec.timeoutMs && runSpec.timeoutMs > 0) {
+                timeout = setTimeout(() => {
+                    terminalPhase = "process-timeout";
+                    terminalSummary = `${this.command} exceeded ${runSpec.timeoutMs}ms`;
+                    void setStatus(runSpec, "failed", terminalPhase, terminalSummary, detectedNativeSessionId);
+                    child.kill("SIGTERM");
+                    void appendText(runSpec.outputLogPath, `\nProcess timed out after ${runSpec.timeoutMs}ms\n`);
+                }, runSpec.timeoutMs);
+            }
+            if (runSpec.firstOutputTimeoutMs && runSpec.firstOutputTimeoutMs > 0) {
+                firstOutputTimeout = setTimeout(() => {
+                    if (sawOutput || settled) {
+                        return;
+                    }
+                    terminalPhase = "process-first-output-timeout";
+                    terminalSummary = `${this.command} produced no first output for ${runSpec.firstOutputTimeoutMs}ms`;
+                    void setStatus(runSpec, "failed", terminalPhase, terminalSummary, detectedNativeSessionId);
+                    child.kill("SIGTERM");
+                    void appendText(runSpec.outputLogPath, `\nProcess produced no first output after ${runSpec.firstOutputTimeoutMs}ms\n`);
+                }, runSpec.firstOutputTimeoutMs);
+            }
+            void setStatus(runSpec, "running", "process-running", `${this.command} running`, detectedNativeSessionId);
+            resetIdleTimeout();
+            child.stdin.write(runSpec.prompt);
+            child.stdin.end();
+        });
+    }
+}
+function buildLaunch(defaultArgs, nativeSession, nativeSessionConfig, modelConfig) {
+    const modelArgs = buildModelArgs(modelConfig);
+    if (!nativeSession || !nativeSessionConfig?.enabled || nativeSessionConfig.resumeArgs.length === 0) {
+        return buildFreshLaunch(defaultArgs, modelConfig);
+    }
+    return {
+        args: [
+            ...nativeSessionConfig.resumeArgs.map((arg) => renderTemplate(arg, nativeSession.session_id, modelConfig)),
+            ...modelArgs
+        ],
+        isResume: true,
+        nativeSession
+    };
+}
+function buildFreshLaunch(defaultArgs, modelConfig) {
+    return {
+        args: [...defaultArgs, ...buildModelArgs(modelConfig)],
+        isResume: false,
+        nativeSession: null
+    };
+}
+function buildModelArgs(modelConfig) {
+    if (!modelConfig || modelConfig.args.length === 0) {
+        return [];
+    }
+    return modelConfig.args.map((arg) => renderTemplate(arg, undefined, modelConfig));
+}
+function buildModelEnv(modelConfig) {
+    if (!modelConfig?.env) {
+        return {};
+    }
+    return Object.fromEntries(Object.entries(modelConfig.env).map(([key, value]) => [key, renderTemplate(value, undefined, modelConfig)]));
+}
+function shouldFallbackToNewNativeSession(attempt, nativeSessionConfig) {
+    return (attempt.launch.isResume &&
+        attempt.result.exitCode !== 0 &&
+        nativeSessionConfig?.fallback === "new" &&
+        isUnrecoverableNativeResumeOutput(attempt.output));
+}
+function isUnrecoverableNativeResumeOutput(output) {
+    const normalized = output.toLowerCase();
+    return (normalized.includes("context window") ||
+        normalized.includes("ran out of room") ||
+        normalized.includes("clear earlier history") ||
+        normalized.includes("start a new thread"));
+}
+function renderTemplate(value, sessionId, modelConfig) {
+    return value
+        .replaceAll("{sessionId}", sessionId ?? "")
+        .replaceAll("{model}", modelConfig?.name ?? "")
+        .replaceAll("{provider}", modelConfig?.provider ?? "")
+        .replace(/\{env:([A-Za-z_][A-Za-z0-9_]*)\}/g, (_match, name) => process.env[name] ?? "");
+}
+function summarizeOutput(text) {
+    const lines = text
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    const summary = lines.at(-1) ?? "Worker produced output";
+    return summary.length > 160 ? `${summary.slice(0, 157)}...` : summary;
+}
+async function setStatus(spec, state, phase, summary, nativeSessionId) {
+    await writeJson(spec.statusPath, {
+        worker_id: spec.workerId,
+        role: spec.role,
+        engine: spec.engine,
+        state,
+        phase,
+        last_event_at: new Date().toISOString(),
+        summary,
+        ...(nativeSessionId ? { native_session_id: nativeSessionId } : {})
+    });
+}
+function detectNativeSessionId(text) {
+    const match = text.match(/\b(?:session id|session_id|session)\s*[:=]\s*([A-Za-z0-9._:@-]{4,})/i);
+    return match?.[1] ?? null;
+}

package/dist/workers/registry.js

@@ -0,0 +1,32 @@
+import { MockWorkerAdapter } from "./mock-adapter.js";
+import { ProcessWorkerAdapter } from "./process-adapter.js";
+export function createWorkerRegistry(config) {
+    return new Map([
+        ["mock", new MockWorkerAdapter()],
+        [
+            "codex",
+            new ProcessWorkerAdapter(config.workers.codex.command, config.workers.codex.args, "codex", {
+                timeoutMs: config.workers.codex.timeoutMs,
+                idleTimeoutMs: config.workers.codex.idleTimeoutMs,
+                firstOutputTimeoutMs: config.workers.codex.firstOutputTimeoutMs,
+                model: config.workers.codex.model
+            })
+        ],
+        [
+            "claude",
+            new ProcessWorkerAdapter(config.workers.claude.command, config.workers.claude.args, "claude", {
+                timeoutMs: config.workers.claude.timeoutMs,
+                idleTimeoutMs: config.workers.claude.idleTimeoutMs,
+                firstOutputTimeoutMs: config.workers.claude.firstOutputTimeoutMs,
+                model: config.workers.claude.model
+            })
+        ]
+    ]);
+}
+export function getAdapter(registry, engine) {
+    const adapter = registry.get(engine);
+    if (!adapter) {
+        throw new Error(`No worker adapter registered for engine: ${engine}`);
+    }
+    return adapter;
+}

package/dist/workers/types.js

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

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "parallel-codex-tui",
+  "version": "0.1.0",
+  "description": "A TypeScript TUI wrapper for routed parallel coding with Codex and Claude workers.",
+  "license": "MIT",
+  "type": "module",
+  "keywords": [
+    "codex",
+    "claude",
+    "tui",
+    "parallel-coding",
+    "agent-orchestration"
+  ],
+  "engines": {
+    "node": ">=22.5.0"
+  },
+  "bin": {
+    "parallel-codex-tui": "dist/cli.js"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE",
+    ".parallel-codex/config.example.toml"
+  ],
+  "scripts": {
+    "dev": "tsx src/cli.tsx",
+    "build": "tsc -p tsconfig.json",
+    "postbuild": "node -e \"require('node:fs').chmodSync('dist/cli.js', 0o755)\"",
+    "prepack": "npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit -p tsconfig.typecheck.json",
+    "lint": "tsc --noEmit -p tsconfig.typecheck.json"
+  },
+  "dependencies": {
+    "@iarna/toml": "^2.2.5",
+    "@xterm/headless": "^6.0.0",
+    "ink": "^5.0.1",
+    "ink-text-input": "^6.0.0",
+    "node-pty": "^1.1.0",
+    "react": "^18.3.1",
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.0",
+    "@types/react": "^18.3.0",
+    "ink-testing-library": "^3.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.8.0",
+    "vitest": "^3.2.0"
+  }
+}