@sprid/cli 0.1.6 → 0.1.7

package/src/tools.mjs

@@ -0,0 +1,85 @@
+// The server's tools, called the way an MCP client calls them. Every command
+// built on this runs through the same handler, scopes and tenant checks as an
+// agent's call, so the CLI cannot drift from what MCP does: REST = MCP = CLI.
+//
+// /api/mcp is stateless JSON-RPC, so a single POST per call is enough; no
+// initialize handshake is needed.
+
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { UsageError } from "./args.mjs";
+import { ApiError } from "./http.mjs";
+
+const MCP_PATH = "/api/mcp?surface=all";
+
+async function rpc(ctx, method, params) {
+  const res = await ctx.api().post(MCP_PATH, { jsonrpc: "2.0", id: 1, method, params });
+  if (res?.error) throw new ApiError(0, res.error.message ?? `The server refused ${method}.`);
+  return res?.result;
+}
+
+/** One tool's result, exactly as its handler returned it. */
+export async function callTool(ctx, name, args = {}) {
+  const result = await rpc(ctx, "tools/call", { name, arguments: args });
+  const text = result?.content?.find((c) => c.type === "text")?.text;
+  if (text === undefined) return result?.structuredContent ?? null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+
+/** Every tool this token's scopes allow, with its input schema. */
+export async function listTools(ctx) {
+  return (await rpc(ctx, "tools/list", {}))?.tools ?? [];
+}
+
+/** `--file args.json`, `--args '{"a":1}'`, or both (the flag wins per key). */
+export async function toolArgs(ctx) {
+  let args = {};
+  if (typeof ctx.flags.file === "string") args = await readJson(ctx, ctx.flags.file);
+  if (typeof ctx.flags.args === "string") {
+    try {
+      args = { ...args, ...JSON.parse(ctx.flags.args) };
+    } catch {
+      throw new UsageError("--args must be a JSON object, such as --args '{\"account\":\"myapp\"}'.");
+    }
+  }
+  return args;
+}
+
+export async function readJson(ctx, path) {
+  const full = resolve(ctx.cwd, path);
+  let text;
+  try {
+    text = await readFile(full, "utf8");
+  } catch {
+    throw new UsageError(`Cannot read ${path}.`);
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new UsageError(`${path} is not valid JSON.`);
+  }
+}
+
+/** A comma list flag as an array; undefined when the flag is absent. */
+export function listFlag(value) {
+  if (typeof value !== "string") return undefined;
+  const items = value.split(",").map((v) => v.trim()).filter(Boolean);
+  return items.length ? items : undefined;
+}
+
+/** A positive integer positional, or a usage error naming the command. */
+export function needInt(arg, usage) {
+  const n = Number(arg);
+  if (!Number.isInteger(n) || n <= 0) throw new UsageError(usage);
+  return n;
+}
+
+/** Human output for results with no bespoke renderer. */
+export function show(ctx, result) {
+  if (ctx.json) ctx.out(result);
+  else ctx.print(JSON.stringify(result, null, 2));
+}