@plutojl/mcp 0.1.0 → 0.3.0

package/dist/cli.cjs

@@ -39340,7 +39340,9 @@ Usage:
 
 Commands:
   run       Start the MCP server (and Pluto server if needed)
-  install   Add MCP config to .claude/ or .vscode/ directory
+  install   Add MCP config to .mcp.json or mcp.json
+  tools     List available MCP tools on a running server
+  call      Call an MCP tool on a running server
 
 Run options:
   --mcp-port <port>        MCP server port (default: ${DEFAULTS.mcpPort})
@@ -39355,13 +39357,26 @@ Install options:
   --dry-run                Print config without writing
   --force                  Overwrite existing config without prompting
 
+Call options:
+  npx @plutojl/mcp call <tool_name> [json_args]
+  --mcp-port <port>        MCP server port (default: ${DEFAULTS.mcpPort})
+  --raw                    Output raw JSON response
+
+Tools options:
+  --mcp-port <port>        MCP server port (default: ${DEFAULTS.mcpPort})
+
 Examples:
   npx @plutojl/mcp run
   npx @plutojl/mcp run --pluto-url http://localhost:1234
   npx @plutojl/mcp install
   npx @plutojl/mcp install --target all --global
+  npx @plutojl/mcp tools
+  npx @plutojl/mcp call get_notebook_status
+  npx @plutojl/mcp call start_pluto_server '{"port": 1234}'
+  npx @plutojl/mcp call open_notebook '{"path": "/tmp/nb.pluto.jl"}'
 `);
 }
+var COMMANDS = /* @__PURE__ */ new Set(["run", "install", "call", "tools", "help"]);
 function parseArgs(argv) {
   const args = { command: "help" };
   let i = 0;
@@ -39374,7 +39389,7 @@ function parseArgs(argv) {
   }
   if (i < argv.length) {
     const cmd = argv[i];
-    if (cmd === "run" || cmd === "install" || cmd === "help") {
+    if (COMMANDS.has(cmd)) {
       args.command = cmd;
     } else {
       console.error(`Unknown command: ${cmd}`);
@@ -39383,6 +39398,16 @@ function parseArgs(argv) {
     }
     i++;
   }
+  if (args.command === "call") {
+    while (i < argv.length && !argv[i].startsWith("-")) {
+      if (!args.toolName) {
+        args.toolName = argv[i];
+      } else if (!args.toolArgs) {
+        args.toolArgs = argv[i];
+      }
+      i++;
+    }
+  }
   while (i < argv.length) {
     const flag = argv[i];
     if (flag === "--help" || flag === "-h") {
@@ -39413,6 +39438,8 @@ function parseArgs(argv) {
       args.dryRun = true;
     } else if (flag === "--force") {
       args.force = true;
+    } else if (flag === "--raw") {
+      args.raw = true;
     } else {
       console.warn(`Unknown flag: ${flag}`);
     }
@@ -63662,10 +63689,8 @@ async function run(config) {
   console.log(`[cli] Health check: http://localhost:${config.mcpPort}/health`);
   console.log(`[cli] Press Ctrl+C to stop
 `);
-  console.log(
-    `Tip: Run 'npx @plutojl/mcp install' to configure Claude Code
-`
-  );
+  console.log(`Tip: Run 'npx @plutojl/mcp install' to configure Claude Code
+`);
   const shutdown = async () => {
     console.log("\n[cli] Shutting down...");
     try {
@@ -63759,9 +63784,208 @@ async function installMcpConfig(args) {
   }
 }
 
+// ../../src/cli/call.ts
+async function mcpRequest(port, method, params = {}) {
+  const sseUrl = `http://localhost:${port}/mcp`;
+  const sseResponse = await fetch(sseUrl, {
+    headers: { Accept: "text/event-stream" }
+  });
+  if (!sseResponse.ok || !sseResponse.body) {
+    throw new Error(
+      `Failed to connect to MCP server at ${sseUrl} (${sseResponse.status})`
+    );
+  }
+  const reader = sseResponse.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer2 = "";
+  let sessionUrl;
+  while (!sessionUrl) {
+    const { done, value } = await reader.read();
+    if (done) throw new Error("SSE stream ended before receiving endpoint");
+    buffer2 += decoder.decode(value, { stream: true });
+    const lines = buffer2.split("\n");
+    for (let i = 0; i < lines.length - 1; i++) {
+      const line = lines[i];
+      if (line.startsWith("data: ") && !sessionUrl) {
+        sessionUrl = line.slice(6).trim();
+      }
+    }
+    buffer2 = lines[lines.length - 1];
+  }
+  const messagesUrl = `http://localhost:${port}${sessionUrl}`;
+  const requestId = 1;
+  await fetch(messagesUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 0,
+      method: "initialize",
+      params: {
+        protocolVersion: "2024-11-05",
+        capabilities: {},
+        clientInfo: { name: "plutojl-mcp-cli", version: "0.1.0" }
+      }
+    })
+  });
+  let initDone = false;
+  while (!initDone) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer2 += decoder.decode(value, { stream: true });
+    if (buffer2.includes('"initialize"') || buffer2.includes('"id":0')) {
+      initDone = true;
+    }
+  }
+  await fetch(messagesUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      method: "notifications/initialized"
+    })
+  });
+  await fetch(messagesUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: requestId,
+      method,
+      params
+    })
+  });
+  buffer2 = "";
+  const timeout2 = setTimeout(() => {
+    reader.cancel().catch(() => {
+    });
+  }, 3e4);
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer2 += decoder.decode(value, { stream: true });
+      const parts = buffer2.split("\n\n");
+      buffer2 = parts.pop() ?? "";
+      for (const part of parts) {
+        let eventData = "";
+        for (const line of part.split("\n")) {
+          if (line.startsWith("data: ")) {
+            eventData += line.slice(6);
+          }
+        }
+        if (eventData) {
+          try {
+            const parsed = JSON.parse(eventData);
+            if (parsed.id === requestId) {
+              if (parsed.error) {
+                throw new Error(
+                  `MCP error ${parsed.error.code}: ${parsed.error.message}`
+                );
+              }
+              return parsed.result;
+            }
+          } catch (e) {
+            if (e instanceof SyntaxError) continue;
+            throw e;
+          }
+        }
+      }
+    }
+  } finally {
+    clearTimeout(timeout2);
+    reader.cancel().catch(() => {
+    });
+  }
+  throw new Error("No response received from MCP server");
+}
+async function listTools(port) {
+  const result = await mcpRequest(port, "tools/list");
+  const tools = result?.tools ?? [];
+  if (tools.length === 0) {
+    console.log("No tools available.");
+    return;
+  }
+  const maxLen = Math.max(...tools.map((t) => t.name.length));
+  for (const tool of tools) {
+    const params = tool.inputSchema?.properties ? Object.keys(tool.inputSchema.properties) : [];
+    const paramStr = params.length > 0 ? `  (${params.join(", ")})` : "";
+    console.log(
+      `  ${tool.name.padEnd(maxLen)}  ${tool.description ?? ""}${paramStr}`
+    );
+  }
+}
+async function callTool(port, toolName, argsJson, raw2) {
+  let args;
+  try {
+    args = JSON.parse(argsJson);
+  } catch {
+    console.error(`Invalid JSON arguments: ${argsJson}`);
+    process.exit(1);
+  }
+  const result = await mcpRequest(port, "tools/call", {
+    name: toolName,
+    arguments: args
+  });
+  if (raw2) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  const content = result?.content;
+  if (content) {
+    for (const item of content) {
+      if (item.type === "text" && item.text) {
+        console.log(item.text);
+      }
+    }
+  }
+  if (result?.isError) {
+    process.exit(1);
+  }
+}
+
+// ../../src/cli/preflight.ts
+async function preflight(port, opts = {}) {
+  const mcpUrl = `http://localhost:${port}`;
+  let health;
+  try {
+    const res = await fetch(`${mcpUrl}/health`, {
+      signal: AbortSignal.timeout(3e3)
+    });
+    health = await res.json();
+  } catch {
+    console.error(`Error: Cannot reach MCP server at ${mcpUrl}`);
+    console.error(``);
+    console.error(`The MCP server is not running. Start it first:`);
+    console.error(``);
+    console.error(`  npx @plutojl/mcp run`);
+    console.error(``);
+    console.error(
+      `Or, if you are using a different port, pass --mcp-port <port>.`
+    );
+    process.exit(1);
+  }
+  if (opts.requirePluto && !health.plutoServerRunning) {
+    console.error(`Error: MCP server is running but Pluto is not connected.`);
+    console.error(``);
+    console.error(`Start Pluto via the MCP server:`);
+    console.error(``);
+    console.error(`  npx @plutojl/mcp call start_pluto_server`);
+    console.error(``);
+    console.error(`Or connect to an existing Pluto server:`);
+    console.error(``);
+    console.error(
+      `  npx @plutojl/mcp call connect_to_pluto_server '{"port": 1234}'`
+    );
+    process.exit(1);
+  }
+  return { mcpRunning: true, plutoRunning: health.plutoServerRunning };
+}
+
 // ../../src/cli/index.ts
 async function main() {
   const args = parseArgs(process.argv.slice(2));
+  const mcpPort = args.mcpPort ?? DEFAULTS.mcpPort;
   switch (args.command) {
     case "run": {
       const config = resolveRunConfig(args);
@@ -63773,6 +63997,25 @@ async function main() {
       await installMcpConfig(installArgs);
       break;
     }
+    case "tools": {
+      await preflight(mcpPort);
+      await listTools(mcpPort);
+      break;
+    }
+    case "call": {
+      if (!args.toolName) {
+        console.error("Usage: npx @plutojl/mcp call <tool_name> [json_args]");
+        process.exit(1);
+      }
+      await preflight(mcpPort);
+      await callTool(
+        mcpPort,
+        args.toolName,
+        args.toolArgs ?? "{}",
+        args.raw ?? false
+      );
+      break;
+    }
   }
 }
 main().catch((err) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plutojl/mcp",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Standalone MCP server for Pluto.jl notebooks — run with npx @plutojl/mcp",
   "license": "MIT",
   "repository": {