@noimosai/platform-mcp 0.1.3 → 0.1.5

package/dist/cli/team-resources.js

@@ -0,0 +1,222 @@
+import { parseArgs } from "node:util";
+import { PLATFORM_MONITOR_ID, platformCustomToolCreateSchema, platformCustomToolRestoreSchema, platformCustomToolUpdateSchema, platformJsonObjectSchema, platformMemberAccessUpdateSchema, platformMonitorCreateSchema, platformMonitorDestinationInputSchema, platformMonitorEventsQuerySchema, platformMonitorQuoteSchema, platformMonitorResumeSchema, platformTeamSkillRestoreSchema, platformTriggerCreateSchema, platformTriggerDestinationInputSchema, platformTriggerEventsQuerySchema, platformTriggerIdSchema, platformTriggerTypesQuerySchema, platformTriggerUpdateSchema } from "../client/index.js";
+import { CliInputError, jsonOption } from "./input-error.js";
+const OPTIONS = { "input-file": { type: "string" }, "expected-version": { type: "string" }, version: { type: "string" },
+    "idempotency-key": { type: "string" }, limit: { type: "string" }, tool: { type: "string" }, args: { type: "string" }, provider: { type: "string" },
+    interval: { type: "string" }, cron: { type: "string" }, "time-zone": { type: "string" }, name: { type: "string" }, "maximum-charge-micros-per-run": { type: "string" }, monitor: { type: "string" },
+    after: { type: "string" }, connection: { type: "string" }, "items-path": { type: "string" }, "maximum-charge-micros-per-poll": { type: "string" }, type: { type: "string" }, config: { type: "string" },
+    destinations: { type: "string" }, destination: { type: "string" }, "destination-id": { type: "string" }, enabled: { type: "string" }, app: { type: "string" }, query: { type: "string" },
+    offset: { type: "string" }, trigger: { type: "string" }, tools: { type: "string" }, all: { type: "boolean" } };
+const COMMON = {
+    "custom-tools": { list: client => client.customTools(), get: name => client => client.customTool(name), versions: name => client => client.customToolVersions(name), delete: name => client => client.deleteCustomTool(name) },
+    "team-skills": { list: client => client.teamSkills(), get: slug => client => client.teamSkill(slug), versions: slug => client => client.teamSkillVersions(slug), delete: slug => client => client.deleteTeamSkill(slug) },
+};
+export const isTeamResource = (name) => Object.hasOwn(COMMON, name) || ["monitors", "triggers", "access"].includes(name);
+function parsed(args, allowed) {
+    const { values, tokens } = parseArgs({ args: args.slice(2), tokens: true, allowPositionals: true, options: OPTIONS });
+    const names = tokens.flatMap(token => token.kind === "option" ? [token.name] : []);
+    const refused = names.find((name, index) => names.indexOf(name) !== index || !allowed.some(option => option === name));
+    if (refused)
+        throw new CliInputError(`${names.filter(name => name === refused).length > 1 ? "Duplicate" : "Invalid"} ${args[0]} ${args[1]} option --${refused}`);
+    const positionals = tokens.flatMap(token => token.kind === "positional" ? [token.value] : []);
+    return { values, name: positionals[0], rest: positionals.slice(1) };
+}
+const number = (value) => value === undefined ? undefined : Number(value);
+const json = (name, value) => value === undefined ? undefined : jsonOption(name, value);
+function positiveInteger(value, option) {
+    if (value === undefined || !/^[1-9]\d{0,14}$/.test(value))
+        throw new CliInputError(`--${option} needs a whole number from 1`);
+    return Number(value);
+}
+function named({ name, rest }) {
+    if (!name || rest.length)
+        throw new CliInputError("Provide one name");
+    return name;
+}
+function nothingNamed({ name }, args) {
+    if (name)
+        throw new CliInputError(`${args[0]} ${args[1]} takes no name`);
+}
+async function definitionOf({ values, rest }, readInput) {
+    const piped = rest.length === 1 && rest[0] === "-";
+    if ((rest.length && !piped) || piped === (values["input-file"] !== undefined))
+        throw new CliInputError("Pass the definition with - (stdin) or --input-file <path>");
+    return JSON.parse(await readInput(piped ? "-" : values["input-file"] ?? ""));
+}
+const objectOf = (value) => platformJsonObjectSchema.parse(value);
+function monitorCommand(args, action) {
+    const target = ["tool", "args", "provider", "interval", "cron", "time-zone"];
+    const allowed = action === "create" ? [...target, "name", "maximum-charge-micros-per-run"] : action === "quote" ? target : action === "resume" ? ["maximum-charge-micros-per-run"]
+        : action === "events" ? ["monitor", "after", "limit"] : action === "destination-add" ? ["destination"] : action === "destination-remove" ? ["destination-id"] : [];
+    const input = parsed(args, allowed), { values } = input;
+    const id = () => {
+        if (!input.name || input.rest.length || !PLATFORM_MONITOR_ID.test(input.name))
+            throw new CliInputError("Provide a valid monitor ID");
+        return input.name;
+    };
+    const targetInput = () => ({ tool: values.tool, arguments: json("--args", values.args), provider: values.provider, interval: values.interval, cron: values.cron, timeZone: values["time-zone"] });
+    const accepted = number(values["maximum-charge-micros-per-run"]);
+    switch (action) {
+        case "list":
+            nothingNamed(input, args);
+            return client => client.monitors();
+        case "popular":
+            nothingNamed(input, args);
+            return client => client.popularMonitors();
+        case "tools":
+            nothingNamed(input, args);
+            return client => client.monitorableTools();
+        case "delete": {
+            const monitor = id();
+            return client => client.deleteMonitor(monitor);
+        }
+        case "quote": {
+            nothingNamed(input, args);
+            const body = platformMonitorQuoteSchema.parse(targetInput());
+            return client => client.quoteMonitor(body);
+        }
+        case "create": {
+            nothingNamed(input, args);
+            const body = platformMonitorCreateSchema.parse({ ...targetInput(), name: values.name, maximumChargeMicrosPerRun: accepted });
+            return client => client.createMonitor(body);
+        }
+        case "resume": {
+            const monitor = id(), body = platformMonitorResumeSchema.parse({ maximumChargeMicrosPerRun: accepted });
+            return client => client.resumeMonitor(monitor, body);
+        }
+        case "events": {
+            nothingNamed(input, args);
+            const query = { monitorId: values.monitor, after: values.after, limit: number(values.limit) };
+            platformMonitorEventsQuerySchema.parse({ after: query.after, limit: query.limit });
+            if (query.monitorId !== undefined && !PLATFORM_MONITOR_ID.test(query.monitorId))
+                throw new CliInputError("Provide a valid monitor ID");
+            return client => client.monitorEvents(query);
+        }
+        case "destination-add": {
+            const monitor = id(), body = platformMonitorDestinationInputSchema.parse(json("--destination", values.destination));
+            return client => client.addMonitorDestination(monitor, body);
+        }
+        case "destination-remove": {
+            const monitor = id(), destination = values["destination-id"];
+            if (!destination)
+                throw new CliInputError("Provide --destination-id as relvo monitors list shows it");
+            return client => client.removeMonitorDestination(monitor, destination);
+        }
+        default: throw new CliInputError("Invalid monitors command");
+    }
+}
+function triggerCommand(args, action) {
+    const allowed = action === "create" ? ["connection", "tool", "args", "interval", "items-path", "maximum-charge-micros-per-poll", "type", "config", "destinations", "name"]
+        : action === "update" ? ["enabled", "name"] : action === "types" ? ["app", "connection", "query", "offset", "limit"] : action === "events" ? ["trigger", "after", "limit"]
+            : action === "destination-add" ? ["destination"] : action === "destination-remove" ? ["destination-id"] : [];
+    const input = parsed(args, allowed), { values } = input;
+    const id = () => {
+        if (!input.name || input.rest.length || !platformTriggerIdSchema.safeParse(input.name).success)
+            throw new CliInputError("Provide a valid trigger ID");
+        return input.name;
+    };
+    switch (action) {
+        case "list":
+            nothingNamed(input, args);
+            return client => client.triggers();
+        case "types": {
+            nothingNamed(input, args);
+            const query = platformTriggerTypesQuerySchema.parse({ app: values.app, connectionId: values.connection, query: values.query, offset: number(values.offset), limit: number(values.limit) });
+            return client => client.triggerTypes(query);
+        }
+        case "delete": {
+            const trigger = id();
+            return client => client.deleteTrigger(trigger);
+        }
+        case "update": {
+            if (values.enabled !== undefined && values.enabled !== "true" && values.enabled !== "false")
+                throw new CliInputError("--enabled is true or false");
+            const trigger = id(), body = platformTriggerUpdateSchema.parse({ enabled: values.enabled === undefined ? undefined : values.enabled === "true", name: values.name });
+            return client => client.updateTrigger(trigger, body);
+        }
+        case "create": {
+            nothingNamed(input, args);
+            const fields = { kind: values.tool !== undefined ? "poll" : "webhook", connectionId: values.connection, name: values.name, destinations: json("--destinations", values.destinations),
+                tool: values.tool, arguments: json("--args", values.args), interval: values.interval, itemsPath: values["items-path"],
+                maximumChargeMicrosPerPoll: number(values["maximum-charge-micros-per-poll"]), type: values.type, config: json("--config", values.config) };
+            const body = platformTriggerCreateSchema.parse(Object.fromEntries(Object.entries(fields).filter(([, value]) => value !== undefined)));
+            return client => client.createTrigger(body);
+        }
+        case "events": {
+            nothingNamed(input, args);
+            const query = { triggerId: values.trigger, after: values.after, limit: number(values.limit) };
+            platformTriggerEventsQuerySchema.parse({ after: query.after, limit: query.limit });
+            if (query.triggerId !== undefined && !platformTriggerIdSchema.safeParse(query.triggerId).success)
+                throw new CliInputError("Provide a valid trigger ID");
+            return client => client.triggerEvents(query);
+        }
+        case "destination-add": {
+            const trigger = id(), body = platformTriggerDestinationInputSchema.parse(json("--destination", values.destination));
+            return client => client.addTriggerDestination(trigger, body);
+        }
+        case "destination-remove": {
+            const trigger = id(), destination = values["destination-id"];
+            if (!destination)
+                throw new CliInputError("Provide --destination-id as relvo triggers list shows it");
+            return client => client.removeTriggerDestination(trigger, destination);
+        }
+        default: throw new CliInputError("Invalid triggers command");
+    }
+}
+function accessCommand(args, action) {
+    if (action === "list") {
+        nothingNamed(parsed(args, []), args);
+        return client => client.access();
+    }
+    if (action !== "set")
+        throw new CliInputError("Invalid access command");
+    const input = parsed(args, ["tools", "all"]), { values } = input;
+    if (!input.name || input.rest.length || !/^[A-Za-z0-9-]{1,128}$/.test(input.name))
+        throw new CliInputError("Provide one member ID as relvo access list shows it");
+    if (Boolean(values.all) === (values.tools !== undefined))
+        throw new CliInputError("Pass --tools '<json array>' or --all");
+    const member = input.name, body = platformMemberAccessUpdateSchema.parse({ toolAccess: values.all ? null : jsonOption("--tools", values.tools ?? "") });
+    return client => client.updateMemberAccess(member, body);
+}
+export async function teamResourceCommand(args, readInput) {
+    const [resource, action = ""] = args;
+    if (resource === "monitors")
+        return monitorCommand(args, action);
+    if (resource === "triggers")
+        return triggerCommand(args, action);
+    if (resource === "access")
+        return accessCommand(args, action);
+    const common = COMMON[resource];
+    if (!common)
+        throw new CliInputError(`Invalid ${resource} command`);
+    if (action === "list") {
+        nothingNamed(parsed(args, []), args);
+        return common.list;
+    }
+    if (action === "get" || action === "versions" || action === "delete")
+        return common[action](named(parsed(args, [])));
+    if (action === "restore") {
+        const input = parsed(args, ["version", "expected-version"]), name = named(input);
+        const versions = { version: positiveInteger(input.values.version, "version"), expectedVersion: positiveInteger(input.values["expected-version"], "expected-version") };
+        if (resource === "custom-tools") {
+            const body = platformCustomToolRestoreSchema.parse(versions);
+            return client => client.restoreCustomTool(name, body);
+        }
+        const body = platformTeamSkillRestoreSchema.parse(versions);
+        return client => client.restoreTeamSkill(name, body);
+    }
+    if ((action === "create" || action === "update") && resource !== "team-skills") {
+        const input = parsed(args, action === "create" ? ["input-file"] : ["input-file", "expected-version"]);
+        if (!input.name)
+            throw new CliInputError("Provide one name");
+        const name = input.name, definition = objectOf(await definitionOf(input, readInput));
+        if (action === "create") {
+            const body = platformCustomToolCreateSchema.parse({ ...definition, slug: name });
+            return client => client.createCustomTool(body);
+        }
+        const expectedVersion = positiveInteger(input.values["expected-version"], "expected-version");
+        const body = platformCustomToolUpdateSchema.parse({ ...definition, expectedVersion });
+        return client => client.updateCustomTool(name, body);
+    }
+    throw new CliInputError(resource === "team-skills" ? "Invalid team-skills command. relvo team-skills push <file or folder> shares or updates one" : `Invalid ${resource} command`);
+}