@1key4ai/mcp-studio 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+/**
+ * @1key4ai/mcp-studio — 1K4 Studio bridge MCP server for Claude Code.
+ *
+ * Exposes tools for interacting with 1K4 Studio agent sessions:
+ * send messages, wait for user input, manage files, answer questionnaires.
+ *
+ * Split from @1key4ai/mcp-review in v0.1.7 so review and studio tools
+ * live in separate MCP servers (1k4-review vs 1k4-studio).
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,638 @@
+#!/usr/bin/env node
+/**
+ * @1key4ai/mcp-studio — 1K4 Studio bridge MCP server for Claude Code.
+ *
+ * Exposes tools for interacting with 1K4 Studio agent sessions:
+ * send messages, wait for user input, manage files, answer questionnaires.
+ *
+ * Split from @1key4ai/mcp-review in v0.1.7 so review and studio tools
+ * live in separate MCP servers (1k4-review vs 1k4-studio).
+ */
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+const API_BASE = process.env.ONEKEY_API_BASE || "https://1key4ai.com";
+const API_KEY = process.env.ONEKEY_API_KEY || "";
+if (!API_KEY) {
+    console.error("Error: ONEKEY_API_KEY environment variable is required.\n" +
+        "Run: npx -y -p @1key4ai/mcp-review mcp-review setup --api-key sk-xxx");
+    process.exit(1);
+}
+// ---------------------------------------------------------------------------
+// API helpers
+// ---------------------------------------------------------------------------
+async function fetchWithRetry(url, options, maxRetries = 3) {
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            const res = await fetch(url, options);
+            if (res.status === 429) {
+                if (attempt < maxRetries) {
+                    const retryAfter = parseInt(res.headers.get("Retry-After") || "5", 10);
+                    console.error(`Rate limited, waiting ${retryAfter}s (${attempt + 1}/${maxRetries})`);
+                    await new Promise(r => setTimeout(r, retryAfter * 1000));
+                    continue;
+                }
+                throw new Error(`Rate limited after ${maxRetries} retries. Try again later.`);
+            }
+            if (res.status >= 500) {
+                if (attempt < maxRetries) {
+                    console.error(`Server error ${res.status}, retrying (${attempt + 1}/${maxRetries})`);
+                    await new Promise(r => setTimeout(r, 1000 * Math.pow(2, attempt)));
+                    continue;
+                }
+                throw new Error(`Server error ${res.status} after ${maxRetries} retries.`);
+            }
+            return res;
+        }
+        catch (err) {
+            if (attempt === maxRetries)
+                throw err;
+            console.error(`Network error, retrying (${attempt + 1}/${maxRetries}): ${err}`);
+            await new Promise(r => setTimeout(r, 1000 * Math.pow(2, attempt)));
+        }
+    }
+    throw new Error("Unreachable");
+}
+// ---------------------------------------------------------------------------
+// Bridge API helpers
+// ---------------------------------------------------------------------------
+async function sendMessage(params) {
+    const res = await fetchWithRetry(`${API_BASE}/api/mcp/send-message`, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${API_KEY}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(params),
+    });
+    if (res.status === 401) {
+        throw new Error("Invalid API key. Check your ONEKEY_API_KEY environment variable. " +
+            "Get a key at https://1key4ai.com/claude-code/setup");
+    }
+    if (res.status === 402) {
+        const data = await res.json().catch(() => ({}));
+        throw new Error(`Insufficient credits: ${String(data.message || "No balance remaining")}. ` +
+            `Add credits: ${String(data.add_credits_url || "https://1key4ai.com/billing")}`);
+    }
+    if (res.status === 409) {
+        throw new Error("Agent is already working on this session. Wait for it to finish or check status.");
+    }
+    if (res.status === 400) {
+        const data = await res.json().catch(() => ({}));
+        throw new Error(`Bad request: ${String(data.error || "Invalid input")}`);
+    }
+    if (!res.ok) {
+        const err = await res.text();
+        throw new Error(`Send message failed (${res.status}): ${err}`);
+    }
+    return await res.json();
+}
+async function getSessionStatus(sessionId) {
+    const res = await fetchWithRetry(`${API_BASE}/api/mcp/session/${encodeURIComponent(sessionId)}/status`, { headers: { Authorization: `Bearer ${API_KEY}` } });
+    if (res.status === 401) {
+        throw new Error("Invalid API key. Check your ONEKEY_API_KEY environment variable.");
+    }
+    if (!res.ok) {
+        const err = await res.text();
+        throw new Error(`Get session status failed (${res.status}): ${err}`);
+    }
+    return await res.json();
+}
+async function listSessionFiles(sessionId) {
+    const res = await fetchWithRetry(`${API_BASE}/api/mcp/session/${encodeURIComponent(sessionId)}/files`, { headers: { Authorization: `Bearer ${API_KEY}` } });
+    if (res.status === 401) {
+        throw new Error("Invalid API key. Check your ONEKEY_API_KEY environment variable.");
+    }
+    if (!res.ok) {
+        const err = await res.text();
+        throw new Error(`List files failed (${res.status}): ${err}`);
+    }
+    return await res.json();
+}
+async function getSessionFile(sessionId, filePath) {
+    const encodedPath = filePath.split("/").map(s => encodeURIComponent(s)).join("/");
+    const res = await fetchWithRetry(`${API_BASE}/api/mcp/session/${encodeURIComponent(sessionId)}/files/${encodedPath}`, { headers: { Authorization: `Bearer ${API_KEY}` } });
+    if (res.status === 401) {
+        throw new Error("Invalid API key. Check your ONEKEY_API_KEY environment variable.");
+    }
+    if (res.status === 404) {
+        throw new Error(`File not found: ${filePath}`);
+    }
+    if (!res.ok) {
+        const err = await res.text();
+        throw new Error(`Get file failed (${res.status}): ${err}`);
+    }
+    return await res.json();
+}
+async function answerQuestionnaire(sessionId, answers) {
+    const res = await fetchWithRetry(`${API_BASE}/api/mcp/session/${encodeURIComponent(sessionId)}/questionnaire`, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${API_KEY}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ answers }),
+    });
+    if (res.status === 401) {
+        throw new Error("Invalid API key. Check your ONEKEY_API_KEY environment variable.");
+    }
+    if (res.status === 402) {
+        const data = await res.json().catch(() => ({}));
+        throw new Error(`Insufficient credits: ${String(data.message || "No balance remaining")}. ` +
+            `Add credits: ${String(data.add_credits_url || "https://1key4ai.com/billing")}`);
+    }
+    if (res.status === 400) {
+        const data = await res.json().catch(() => ({}));
+        throw new Error(`Bad request: ${String(data.error || "No pending questionnaire")}`);
+    }
+    if (!res.ok) {
+        const err = await res.text();
+        throw new Error(`Answer questionnaire failed (${res.status}): ${err}`);
+    }
+    return await res.json();
+}
+async function pollUntilDone(sessionId) {
+    const pollInterval = 5000;
+    const maxWait = 600000;
+    const start = Date.now();
+    while (Date.now() - start < maxWait) {
+        await new Promise(r => setTimeout(r, pollInterval));
+        let pollRes;
+        try {
+            pollRes = await fetchWithRetry(`${API_BASE}/api/mcp/session/${encodeURIComponent(sessionId)}/status`, { headers: { Authorization: `Bearer ${API_KEY}` } });
+        }
+        catch (networkErr) {
+            console.error(`Poll network error (will retry): ${networkErr}`);
+            continue;
+        }
+        if (pollRes.status === 401) {
+            throw new Error("Invalid API key during poll.");
+        }
+        if (!pollRes.ok) {
+            throw new Error(`Poll failed (${pollRes.status})`);
+        }
+        const data = await pollRes.json();
+        if (data.status === "working") {
+            console.error(`Session ${sessionId} still working...`);
+            continue;
+        }
+        return data;
+    }
+    throw new Error("Agent timed out after 10 minutes. Use 1k4_get_session_status to check later.");
+}
+function formatBridgeResponse(data, sessionId) {
+    const lines = [];
+    if (data.response) {
+        lines.push(String(data.response));
+        lines.push("");
+    }
+    if (data.status === "waiting_for_input" && data.pending_questionnaire) {
+        const questionnaire = data.pending_questionnaire;
+        if (questionnaire.intro) {
+            lines.push(String(questionnaire.intro));
+            lines.push("");
+        }
+        lines.push("The agent needs your answers:");
+        const items = (questionnaire.items || questionnaire.questions);
+        if (items && Array.isArray(items)) {
+            for (let i = 0; i < items.length; i++) {
+                const q = items[i];
+                const qType = q.type ? ` [${q.type}]` : "";
+                lines.push(`  ${i + 1}. ${String(q.question || q.text || q.label || "")}${qType}`);
+                if (q.options && Array.isArray(q.options)) {
+                    for (const opt of q.options) {
+                        const label = typeof opt === "string" ? opt : String(opt.label || opt);
+                        const rec = (typeof opt === "object" && opt.recommended) ? " (recommended)" : "";
+                        lines.push(`     - ${label}${rec}`);
+                    }
+                }
+                if (q.recommendation) {
+                    lines.push(`     Suggested: ${q.recommendation}`);
+                }
+            }
+        }
+        lines.push("");
+        lines.push("Use 1k4_answer_questionnaire with the session_id and your answers.");
+        lines.push("");
+    }
+    if (data.status === "error") {
+        lines.push("Status: error");
+        lines.push("");
+    }
+    const filesCreated = data.files_created;
+    if (filesCreated && filesCreated.length > 0) {
+        lines.push(`Files created/modified (${filesCreated.length}):`);
+        for (const f of filesCreated) {
+            lines.push(`  - ${f}`);
+        }
+        lines.push("");
+    }
+    if (data.files_count) {
+        lines.push(`Total files in project: ${data.files_count}`);
+    }
+    lines.push(`session_id: ${sessionId}`);
+    if (data.studio_url) {
+        lines.push(`Studio URL: ${data.studio_url}`);
+    }
+    return lines.join("\n");
+}
+// ---------------------------------------------------------------------------
+// MCP Server
+// ---------------------------------------------------------------------------
+const server = new Server({ name: "1k4-studio", version: "0.1.0" }, { capabilities: { tools: {} } });
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+        {
+            name: "1k4_send_message",
+            description: "Send a message to a 1K4 Studio agent session. The agent processes your " +
+                "request (code generation, analysis, file creation, etc.) and this tool " +
+                "polls until the agent finishes. Returns session_id. Pass this session_id " +
+                "to all subsequent calls to continue the conversation in the same session. " +
+                "When acting as the session's external agent (after 1k4_wait_for_message), " +
+                "pass role='assistant' to send your response without triggering the Studio agent.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    message: {
+                        type: "string",
+                        description: "The message to send to the agent.",
+                    },
+                    session_id: {
+                        type: "string",
+                        description: "Session ID from a previous call. Omit on first call to auto-create a new session.",
+                    },
+                    model: {
+                        type: "string",
+                        description: "Optional model override (e.g., 'claude-sonnet-4-20250514').",
+                    },
+                    role: {
+                        type: "string",
+                        description: "Message role: 'user' (default, triggers Studio agent) or 'assistant' " +
+                            "(external-agent response, no agent task). Use 'assistant' only after " +
+                            "1k4_wait_for_message has set external_agent mode on the session.",
+                    },
+                },
+                required: ["message"],
+            },
+        },
+        {
+            name: "1k4_wait_for_message",
+            description: "Wait for a user message in a 1K4 Studio session. Long-polls the " +
+                "backend (up to 5 minutes internally) and returns when the user types " +
+                "a message in the Studio UI. Use in a loop to act as the session's " +
+                "agent: wait for message -> process -> 1k4_send_message(role='assistant') -> repeat. " +
+                "On first call (no after_seq), initializes a cursor and starts listening. " +
+                "Pass the returned 'seq' as 'after_seq' on subsequent calls. " +
+                "Sets the session to external_agent mode (suppresses Studio agent tasks). " +
+                "Auto-reverts after 2 min of no polling if Claude Code disconnects.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    session_id: {
+                        type: "string",
+                        description: "The session to listen on.",
+                    },
+                    after_seq: {
+                        type: "string",
+                        description: "Sequence cursor from previous response. Omit on first call.",
+                    },
+                },
+                required: ["session_id"],
+            },
+        },
+        {
+            name: "1k4_get_session_status",
+            description: "Check the current status of a 1K4 Studio session. Returns instantly " +
+                "(no polling). Use to check if an agent is still working, or to see the " +
+                "latest response and files after a timeout.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    session_id: {
+                        type: "string",
+                        description: "The session ID to check.",
+                    },
+                },
+                required: ["session_id"],
+            },
+        },
+        {
+            name: "1k4_list_files",
+            description: "List all files in a 1K4 Studio project workspace. Returns file names, " +
+                "paths, mime types, and sizes.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    session_id: {
+                        type: "string",
+                        description: "The session ID (used to resolve the project workspace).",
+                    },
+                },
+                required: ["session_id"],
+            },
+        },
+        {
+            name: "1k4_get_file",
+            description: "Download the content of a specific file from a 1K4 Studio project workspace. " +
+                "For text files, returns the full content. For binary files (images, etc.), " +
+                "returns metadata only.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    session_id: {
+                        type: "string",
+                        description: "The session ID (used to resolve the project workspace).",
+                    },
+                    file_path: {
+                        type: "string",
+                        description: "Path to the file (e.g., 'src/index.ts'). Use paths from 1k4_list_files.",
+                    },
+                },
+                required: ["session_id", "file_path"],
+            },
+        },
+        {
+            name: "1k4_answer_questionnaire",
+            description: "Answer a pending questionnaire from the 1K4 Studio agent. When a session " +
+                "has status 'waiting_for_input', the agent needs answers before proceeding. " +
+                "Polls until the agent finishes processing the answers.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    session_id: {
+                        type: "string",
+                        description: "The session ID with the pending questionnaire.",
+                    },
+                    answers: {
+                        type: "array",
+                        items: {
+                            type: "object",
+                            properties: {
+                                question_index: {
+                                    type: "number",
+                                    description: "Zero-based index of the question being answered.",
+                                },
+                                value: {
+                                    description: "The answer. String for single-choice, array of strings for multi-select.",
+                                },
+                            },
+                            required: ["question_index", "value"],
+                        },
+                        description: "Array of answers, one per question.",
+                    },
+                },
+                required: ["session_id", "answers"],
+            },
+        },
+    ],
+}));
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const toolName = request.params.name;
+    // -----------------------------------------------------------------------
+    // 1k4_send_message
+    // -----------------------------------------------------------------------
+    if (toolName === "1k4_send_message") {
+        const args = request.params.arguments;
+        if (!args.message) {
+            return {
+                content: [{ type: "text", text: "'message' is required." }],
+                isError: true,
+            };
+        }
+        try {
+            const sendBody = {
+                message: args.message,
+                session_id: args.session_id,
+                model: args.model,
+                role: args.role,
+            };
+            const result = await sendMessage(sendBody);
+            const sessionId = String(result.session_id);
+            // role=assistant responses are complete immediately (no agent task)
+            if (args.role === "assistant") {
+                return {
+                    content: [{ type: "text", text: `Response sent.\n\nsession_id: ${sessionId}` }],
+                };
+            }
+            console.error(`Message sent, session=${sessionId}, polling for completion...`);
+            const data = await pollUntilDone(sessionId);
+            return {
+                content: [{ type: "text", text: formatBridgeResponse(data, sessionId) }],
+            };
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: `Send message error: ${e}` }],
+                isError: true,
+            };
+        }
+    }
+    // -----------------------------------------------------------------------
+    // 1k4_wait_for_message
+    // -----------------------------------------------------------------------
+    if (toolName === "1k4_wait_for_message") {
+        const args = request.params.arguments;
+        if (!args.session_id) {
+            return {
+                content: [{ type: "text", text: "'session_id' is required." }],
+                isError: true,
+            };
+        }
+        try {
+            let seq = args.after_seq || "";
+            const maxIterations = 10;
+            for (let i = 0; i < maxIterations; i++) {
+                const params = new URLSearchParams({ timeout: "30" });
+                if (seq)
+                    params.set("after_seq", seq);
+                console.error(`[1k4] Waiting for message (${i + 1}/${maxIterations})...`);
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), 35_000);
+                let res;
+                try {
+                    res = await fetch(`${API_BASE}/api/mcp/session/${encodeURIComponent(args.session_id)}/wait?${params}`, {
+                        headers: { Authorization: `Bearer ${API_KEY}` },
+                        signal: controller.signal,
+                    });
+                }
+                finally {
+                    clearTimeout(timeoutId);
+                }
+                if (!res.ok) {
+                    const err = await res.text();
+                    const seqSuffix = seq ? `\nafter_seq: ${seq}` : "";
+                    return {
+                        content: [{ type: "text", text: `Wait error (${res.status}): ${err}${seqSuffix}\nsession_id: ${args.session_id}` }],
+                        isError: true,
+                    };
+                }
+                const data = await res.json();
+                if (data.has_message) {
+                    const msg = data.message;
+                    const lines = [
+                        "User message received:",
+                        "",
+                        String(msg.content || ""),
+                        "",
+                        `type: ${msg.message_type || "text"}`,
+                        `seq: ${data.seq}`,
+                        `session_id: ${data.session_id}`,
+                    ];
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                seq = String(data.seq || seq);
+            }
+            return {
+                content: [{ type: "text", text: `No new message after ${maxIterations * 30}s.\n\nseq: ${seq}\nsession_id: ${args.session_id}` }],
+            };
+        }
+        catch (e) {
+            const seqSuffix = args.after_seq ? `\nafter_seq: ${args.after_seq}` : "";
+            if (e.name === "AbortError") {
+                return { content: [{ type: "text", text: `Wait timed out (network).${seqSuffix}\nsession_id: ${args.session_id}` }] };
+            }
+            return {
+                content: [{ type: "text", text: `Wait error: ${e}${seqSuffix}\nsession_id: ${args.session_id}` }],
+                isError: true,
+            };
+        }
+    }
+    // -----------------------------------------------------------------------
+    // 1k4_get_session_status
+    // -----------------------------------------------------------------------
+    if (toolName === "1k4_get_session_status") {
+        const args = request.params.arguments;
+        if (!args.session_id) {
+            return {
+                content: [{ type: "text", text: "'session_id' is required." }],
+                isError: true,
+            };
+        }
+        try {
+            const data = await getSessionStatus(args.session_id);
+            return {
+                content: [{ type: "text", text: formatBridgeResponse(data, args.session_id) }],
+            };
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: `Get session status error: ${e}` }],
+                isError: true,
+            };
+        }
+    }
+    // -----------------------------------------------------------------------
+    // 1k4_list_files
+    // -----------------------------------------------------------------------
+    if (toolName === "1k4_list_files") {
+        const args = request.params.arguments;
+        if (!args.session_id) {
+            return {
+                content: [{ type: "text", text: "'session_id' is required." }],
+                isError: true,
+            };
+        }
+        try {
+            const data = await listSessionFiles(args.session_id);
+            const files = data.files;
+            if (!files || files.length === 0) {
+                return {
+                    content: [{ type: "text", text: `No files in project workspace.\n\nsession_id: ${args.session_id}` }],
+                };
+            }
+            const lines = [`Files (${files.length}):`];
+            for (const f of files) {
+                const size = f.size ? ` (${f.size} bytes)` : "";
+                lines.push(`  ${f.path || f.name}${size}`);
+            }
+            lines.push("");
+            lines.push(`session_id: ${args.session_id}`);
+            return {
+                content: [{ type: "text", text: lines.join("\n") }],
+            };
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: `List files error: ${e}` }],
+                isError: true,
+            };
+        }
+    }
+    // -----------------------------------------------------------------------
+    // 1k4_get_file
+    // -----------------------------------------------------------------------
+    if (toolName === "1k4_get_file") {
+        const args = request.params.arguments;
+        if (!args.session_id || !args.file_path) {
+            return {
+                content: [{ type: "text", text: "'session_id' and 'file_path' are required." }],
+                isError: true,
+            };
+        }
+        try {
+            const data = await getSessionFile(args.session_id, args.file_path);
+            if (data.binary) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Binary file: ${args.file_path} (${data.mime_type}, ${data.size_bytes} bytes)\n` +
+                                `${data.message || "Use Studio URL to view."}\n\nsession_id: ${args.session_id}`,
+                        }],
+                };
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: `File: ${args.file_path}\n\n${String(data.content || "")}\n\nsession_id: ${args.session_id}`,
+                    }],
+            };
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: `Get file error: ${e}` }],
+                isError: true,
+            };
+        }
+    }
+    // -----------------------------------------------------------------------
+    // 1k4_answer_questionnaire
+    // -----------------------------------------------------------------------
+    if (toolName === "1k4_answer_questionnaire") {
+        const args = request.params.arguments;
+        if (!args.session_id || !args.answers) {
+            return {
+                content: [{ type: "text", text: "'session_id' and 'answers' are required." }],
+                isError: true,
+            };
+        }
+        try {
+            await answerQuestionnaire(args.session_id, args.answers);
+            console.error(`Questionnaire answered, session=${args.session_id}, polling for completion...`);
+            const data = await pollUntilDone(args.session_id);
+            return {
+                content: [{ type: "text", text: formatBridgeResponse(data, args.session_id) }],
+            };
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: `Answer questionnaire error: ${e}` }],
+                isError: true,
+            };
+        }
+    }
+    return {
+        content: [{ type: "text", text: `Unknown tool: ${toolName}` }],
+        isError: true,
+    };
+});
+// Start
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("1K4 Studio MCP server running");
+}
+main().catch((e) => {
+    console.error("Fatal:", e);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@1key4ai/mcp-studio",
+  "version": "0.1.0",
+  "description": "1K4 Studio bridge for Claude Code. Send messages, manage files, and act as a Studio agent via MCP tools.",
+  "keywords": [
+    "claude-code",
+    "mcp",
+    "studio",
+    "ai",
+    "onekey",
+    "1k4"
+  ],
+  "license": "MIT",
+  "author": "OneKey <hello@1key4ai.com>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/OneKey-Incorporated/onekey",
+    "directory": "packages/mcp-studio"
+  },
+  "homepage": "https://1key4ai.com/claude-code",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "mcp-studio": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.4.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}