callman-mcp 0.1.0

package/dist-cjs/tools/scenarios.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerScenarioTools = void 0;
+const zod_1 = require("zod");
+const errors_js_1 = require("../client/errors.js");
+const resolve_js_1 = require("../domain/resolve.js");
+const build_js_1 = require("../domain/scenario/build.js");
+const summarize_js_1 = require("../domain/scenario/summarize.js");
+const ids_js_1 = require("../lib/ids.js");
+const pagination_js_1 = require("../lib/pagination.js");
+const lookups_js_1 = require("./lookups.js");
+const shared_js_1 = require("./shared.js");
+const TERMINAL_STATUSES = new Set(["success", "failed", "completed_with_failures", "stopped"]);
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const registerScenarioTools = (server, ctx) => {
+    server.registerTool("list_scenarios", {
+        title: "List scenarios",
+        description: "List API test scenarios (multi-step flows) with their folder, review status and version. `query` filters by name. Scenarios are scoped by edition (on-prem: your groups), not strictly by workspace.",
+        inputSchema: { workspace: shared_js_1.workspaceArg, query: zod_1.z.string().max(200).optional(), folder: zod_1.z.string().max(200).optional(), ...shared_js_1.cursorArgs },
+        annotations: shared_js_1.READ,
+    }, (0, shared_js_1.guarded)(async ({ workspace, query, folder, cursor, limit }) => {
+        const ws = await ctx.resolveWorkspaceOrNull(workspace);
+        const { scenarios, folders } = await (0, lookups_js_1.loadScenarioCatalog)(ctx, ws?.id ?? null);
+        const folderName = new Map(folders.map((entry) => [entry.id, entry.name]));
+        const scope = folder ? await (0, lookups_js_1.resolveScenarioFolder)(ctx, ws?.id ?? null, folder) : null;
+        const needle = query?.trim().toLowerCase();
+        const filtered = scenarios
+            .filter((scenario) => !scope || scenario.folderId === scope.item.id)
+            .filter((scenario) => !needle || scenario.name.toLowerCase().includes(needle));
+        const page = (0, pagination_js_1.sliceWithCursor)(filtered, cursor, limit);
+        return (0, shared_js_1.ok)({
+            ...(ws ? { workspace: { id: ws.id, name: ws.name } } : {}),
+            folders: folders.map((entry) => ({ id: entry.id, name: entry.name })),
+            scenarios: page.items.map((scenario) => (0, summarize_js_1.scenarioSummaryView)(scenario, scenario.folderId ? (folderName.get(scenario.folderId) ?? null) : null)),
+            total: page.total,
+            nextCursor: page.nextCursor,
+        });
+    }));
+    server.registerTool("get_scenario", {
+        title: "Get a scenario",
+        description: "Read a scenario: `summary` (metadata), `graph` (nodes with type/label and the edges — enough to understand the flow) or `full` (node configs, secrets masked, clipped at 2 KB per node). Use `graph` before editing with update_scenario.",
+        inputSchema: {
+            workspace: shared_js_1.workspaceArg,
+            scenario: (0, shared_js_1.refArg)("Scenario"),
+            view: zod_1.z.enum(["summary", "graph", "full"]).default("graph"),
+            reveal: zod_1.z.boolean().optional().describe("full view: return environment values and auth secrets unmasked (needs environments:reveal)"),
+        },
+        annotations: shared_js_1.READ,
+    }, (0, shared_js_1.guarded)(async ({ workspace, scenario, view, reveal }) => {
+        const ws = await ctx.resolveWorkspaceOrNull(workspace);
+        const resolved = await (0, lookups_js_1.resolveScenario)(ctx, ws?.id ?? null, scenario);
+        const fresh = resolved.matched === "id" && !reveal ? resolved.item : await ctx.api.getScenario(ws?.id ?? null, resolved.item.id, reveal ?? false);
+        const body = view === "summary" ? (0, summarize_js_1.scenarioSummaryView)(fresh) : view === "graph" ? (0, summarize_js_1.scenarioGraphView)(fresh) : (0, summarize_js_1.scenarioFullView)(fresh, { reveal });
+        return (0, shared_js_1.ok)({ scenario: body, ...(resolved.annotation ? { resolved: [(0, resolve_js_1.resolvedSummary)(scenario, resolved)] } : {}) });
+    }));
+    server.registerTool("get_scenario_report", {
+        title: "Get a scenario run report",
+        description: "The result of a scenario run: status, summary counts and a per-node timeline (status, duration, HTTP status, failed tests) with the first failed node expanded. Defaults to the latest run.",
+        inputSchema: {
+            workspace: shared_js_1.workspaceArg,
+            scenario: (0, shared_js_1.refArg)("Scenario"),
+            report: zod_1.z.string().max(64).optional().describe("Report id; omit for the latest run"),
+        },
+        annotations: shared_js_1.READ,
+    }, (0, shared_js_1.guarded)(async ({ workspace, scenario, report }) => {
+        const ws = await ctx.resolveWorkspaceOrNull(workspace);
+        const resolved = await (0, lookups_js_1.resolveScenario)(ctx, ws?.id ?? null, scenario);
+        let reportId = report;
+        if (!reportId) {
+            const list = await ctx.api.listScenarioReports(ws?.id ?? null, resolved.item.id, 5);
+            const latest = list.items[0];
+            if (!latest)
+                return (0, shared_js_1.ok)({ scenario: { id: resolved.item.id, name: resolved.item.name }, report: null, note: "This scenario has not been run on the server yet. Use run_scenario." });
+            reportId = latest.reportId;
+        }
+        const detail = await ctx.api.getScenarioReport(ws?.id ?? null, resolved.item.id, reportId);
+        return (0, shared_js_1.ok)({ report: (0, summarize_js_1.compactReportView)(detail), ...(resolved.annotation ? { resolved: [(0, resolve_js_1.resolvedSummary)(scenario, resolved)] } : {}) });
+    }));
+    server.registerTool("create_scenario", {
+        title: "Create a scenario",
+        description: "Create a multi-step API test scenario from compact nodes and edges. Node configs are merged over the type's defaults, so partial configs are fine (a request node needs at least method + url). Read callman://docs/scenario-nodes for every node type and config field. Positions are laid out automatically. dryRun: true returns the resolved graph without saving. On-prem: new scenarios start as drafts and need approval before scheduled/CI runs.",
+        inputSchema: {
+            workspace: shared_js_1.workspaceArg,
+            folder: zod_1.z.string().max(200).optional().describe("Scenario folder id or name"),
+            ...build_js_1.scenarioInputSchema.shape,
+            dryRun: shared_js_1.dryRunArg,
+        },
+        annotations: shared_js_1.WRITE,
+    }, (0, shared_js_1.guarded)(async ({ workspace, folder, dryRun, ...input }) => {
+        const ws = await ctx.resolveWorkspace(workspace);
+        const targetFolder = folder ? await (0, lookups_js_1.resolveScenarioFolder)(ctx, ws.id, folder) : null;
+        const body = (0, build_js_1.buildScenarioCreateBody)(input, targetFolder?.item.id ?? null);
+        if (dryRun) {
+            const nodes = body.nodes;
+            return (0, shared_js_1.ok)({ dryRun: true, scenario: { name: body.name, nodeCount: nodes.length, edgeCount: body.edges.length, nodes: nodes.map((node) => ({ id: node.id, type: node.type, label: node.data.label ?? null })), edges: body.edges } });
+        }
+        const created = await ctx.api.createScenario(ws.id, body);
+        ctx.invalidate("scenarios:");
+        return (0, shared_js_1.ok)({
+            scenario: (0, summarize_js_1.scenarioGraphView)(created),
+            ...(created.graph?.warnings?.length ? { warnings: created.graph.warnings } : {}),
+            note: created.reviewStatus === "draft" ? "Created as a draft. Run it with run_scenario; on-prem, submit it for approval in the desktop app before scheduling." : "Created.",
+            ...(targetFolder ? { resolved: [(0, resolve_js_1.resolvedSummary)(folder, targetFolder)] } : {}),
+        });
+    }));
+    server.registerTool("update_scenario", {
+        title: "Update a scenario",
+        description: "Update a scenario's name/description/priority/folder and/or replace its graph (send nodes AND edges together; node configs merge over defaults like create_scenario). Version-checked: pass the `version` you read (expectedVersion) or it is fetched first; a 409 conflict comes back structured — re-read and retry. On-prem: editing an approved scenario returns it to draft.",
+        inputSchema: {
+            workspace: shared_js_1.workspaceArg,
+            scenario: (0, shared_js_1.refArg)("Scenario"),
+            expectedVersion: zod_1.z.number().int().nonnegative().optional(),
+            force: zod_1.z.boolean().optional().describe("Overwrite even if someone changed it since expectedVersion"),
+            name: zod_1.z.string().min(1).max(200).optional(),
+            description: zod_1.z.string().max(5000).optional(),
+            priority: zod_1.z.enum(["critical", "high", "medium", "low"]).optional(),
+            folder: zod_1.z.string().max(200).nullable().optional().describe("Scenario folder id or name; null = no folder"),
+            nodes: zod_1.z.array(build_js_1.scenarioNodeInputSchema).min(1).max(1000).optional(),
+            edges: zod_1.z.array(build_js_1.scenarioEdgeInputSchema).max(2000).optional(),
+            environments: zod_1.z.array(build_js_1.scenarioEnvironmentInputSchema).max(20).optional(),
+        },
+        annotations: shared_js_1.IDEMPOTENT_WRITE,
+    }, (0, shared_js_1.guarded)(async ({ workspace, scenario, expectedVersion, force, name, description, priority, folder, nodes, edges, environments }) => {
+        if ((nodes === undefined) !== (edges === undefined)) {
+            throw new errors_js_1.ToolInputError("GRAPH_INCOMPLETE", "Send nodes and edges together when replacing the graph.");
+        }
+        const ws = await ctx.resolveWorkspaceOrNull(workspace);
+        const resolved = await (0, lookups_js_1.resolveScenario)(ctx, ws?.id ?? null, scenario);
+        const current = resolved.item;
+        const targetFolder = folder ? await (0, lookups_js_1.resolveScenarioFolder)(ctx, ws?.id ?? null, folder) : null;
+        const body = {
+            ...(name !== undefined ? { name: name.trim() } : {}),
+            ...(description !== undefined ? { description } : {}),
+            ...(priority !== undefined ? { priority } : {}),
+            ...(folder !== undefined ? { folderId: targetFolder?.item.id ?? null } : {}),
+            expectedVersion: expectedVersion ?? current.version,
+            ...(force ? { force: true } : {}),
+        };
+        if (nodes && edges) {
+            const graph = (0, build_js_1.buildScenarioGraph)(nodes, edges);
+            body.nodes = graph.nodes;
+            body.edges = graph.edges;
+        }
+        if (environments) {
+            const nextEnvId = (0, ids_js_1.sequentialIds)("env", current.environments.map((environment) => environment.id));
+            body.environments = environments.map((environment) => {
+                const nextVarId = (0, ids_js_1.sequentialIds)("v");
+                return {
+                    id: environment.id ?? nextEnvId(),
+                    name: environment.name,
+                    variables: environment.variables.filter((variable) => variable.key.trim()).map((variable) => ({ id: nextVarId(), key: variable.key.trim(), value: variable.value ?? "", enabled: variable.enabled ?? true })),
+                };
+            });
+        }
+        if (Object.keys(body).filter((key) => key !== "expectedVersion" && key !== "force").length === 0) {
+            throw new errors_js_1.ToolInputError("NOTHING_TO_UPDATE", "Pass at least one field to change.");
+        }
+        try {
+            const updated = await ctx.api.patchScenario(ws?.id ?? null, current.id, body);
+            ctx.invalidate("scenarios:");
+            return (0, shared_js_1.ok)({
+                scenario: (0, summarize_js_1.scenarioGraphView)(updated),
+                previousVersion: current.version,
+                ...(current.reviewStatus === "approved" && updated.reviewStatus !== "approved" ? { note: "The scenario was approved and is now a draft again; schedules keep using the last approved version until it is re-approved." } : {}),
+                ...(resolved.annotation ? { resolved: [(0, resolve_js_1.resolvedSummary)(scenario, resolved)] } : {}),
+            });
+        }
+        catch (error) {
+            if (error instanceof errors_js_1.CallmanApiError && error.code === "SCENARIO_VERSION_CONFLICT") {
+                const details = (error.details ?? {});
+                return (0, shared_js_1.ok)({
+                    conflict: true,
+                    code: error.code,
+                    message: error.message,
+                    currentVersion: details.currentScenario?.version ?? null,
+                    hint: "Re-read the scenario (get_scenario view:graph), reapply your change and call update_scenario with expectedVersion set to currentVersion — or force: true to overwrite.",
+                });
+            }
+            throw error;
+        }
+    }));
+    server.registerTool("delete_scenario", {
+        title: "Delete a scenario",
+        description: "Delete a scenario and its run history. Permanent — confirm with the user first.",
+        inputSchema: { workspace: shared_js_1.workspaceArg, scenario: (0, shared_js_1.refArg)("Scenario"), confirm: shared_js_1.confirmArg },
+        annotations: shared_js_1.DESTRUCTIVE,
+    }, (0, shared_js_1.guarded)(async ({ workspace, scenario, confirm }) => {
+        (0, shared_js_1.requireConfirm)(confirm, "a scenario");
+        const ws = await ctx.resolveWorkspaceOrNull(workspace);
+        const resolved = await (0, lookups_js_1.resolveScenario)(ctx, ws?.id ?? null, scenario);
+        await ctx.api.deleteScenario(ws?.id ?? null, resolved.item.id);
+        ctx.invalidate("scenarios:");
+        return (0, shared_js_1.ok)({ deleted: { id: resolved.item.id, name: resolved.item.name }, resolved: [(0, resolve_js_1.resolvedSummary)(scenario, resolved)] });
+    }));
+    server.registerTool("run_scenario", {
+        title: "Run a scenario on the server",
+        description: "Start a server-side run of a scenario (with one of its inline environments, by name or id) and wait for the result (default up to 5 minutes, max 30). Returns the compact report; if it times out you get the reportId to check later with get_scenario_report.",
+        inputSchema: {
+            workspace: shared_js_1.workspaceArg,
+            scenario: (0, shared_js_1.refArg)("Scenario"),
+            environment: zod_1.z.string().max(200).optional().describe("One of the scenario's own environments (name or id)"),
+            wait: zod_1.z.boolean().default(true),
+            timeoutSec: zod_1.z.number().int().min(5).max(1800).default(300),
+        },
+        annotations: shared_js_1.RUN,
+    }, (0, shared_js_1.guarded)(async ({ workspace, scenario, environment, wait, timeoutSec }) => {
+        const ws = await ctx.resolveWorkspaceOrNull(workspace);
+        const resolved = await (0, lookups_js_1.resolveScenario)(ctx, ws?.id ?? null, scenario);
+        let environmentId;
+        if (environment) {
+            const environments = resolved.item.environments ?? [];
+            const match = environments.find((entry) => entry.id === environment) ?? environments.filter((entry) => entry.name.trim().toLowerCase() === environment.trim().toLowerCase());
+            const picked = Array.isArray(match) ? (match.length === 1 ? match[0] : null) : match;
+            if (!picked) {
+                throw new errors_js_1.ToolInputError("SCENARIO_ENV_NOT_FOUND", `The scenario has no environment "${environment}".`, { candidates: environments.map((entry) => ({ id: entry.id, name: entry.name })) });
+            }
+            environmentId = picked.id;
+        }
+        const trigger = await ctx.api.runScenario(ws?.id ?? null, resolved.item.id, environmentId ? { environmentId } : {});
+        if (!wait)
+            return (0, shared_js_1.ok)({ scenario: { id: resolved.item.id, name: resolved.item.name }, reportId: trigger.reportId, status: trigger.status, note: "Check with get_scenario_report." });
+        const deadline = Date.now() + timeoutSec * 1000;
+        let polls = 0;
+        let last = null;
+        while (Date.now() < deadline) {
+            await sleep(polls < 5 ? ctx.pollDelaysMs.fast : ctx.pollDelaysMs.slow);
+            polls += 1;
+            try {
+                last = await ctx.api.getScenarioReport(ws?.id ?? null, resolved.item.id, trigger.reportId);
+            }
+            catch (error) {
+                if (error instanceof errors_js_1.CallmanApiError && error.status === 404)
+                    continue; // placeholder not yet visible
+                throw error;
+            }
+            if (TERMINAL_STATUSES.has(last.status))
+                break;
+        }
+        if (!last || !TERMINAL_STATUSES.has(last.status)) {
+            return (0, shared_js_1.ok)({ scenario: { id: resolved.item.id, name: resolved.item.name }, reportId: trigger.reportId, status: last?.status ?? "running", timedOut: true, note: `Still running after ${timeoutSec}s — call get_scenario_report with this reportId later.` });
+        }
+        return (0, shared_js_1.ok)({ report: (0, summarize_js_1.compactReportView)(last), ...(resolved.annotation ? { resolved: [(0, resolve_js_1.resolvedSummary)(scenario, resolved)] } : {}) });
+    }));
+};
+exports.registerScenarioTools = registerScenarioTools;

package/dist-cjs/tools/shared.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireConfirm = exports.dryRunArg = exports.confirmArg = exports.cursorArgs = exports.refArg = exports.workspaceArg = exports.RUN = exports.DESTRUCTIVE = exports.IDEMPOTENT_WRITE = exports.WRITE = exports.READ = exports.guarded = exports.toolFailure = exports.ok = void 0;
+const zod_1 = require("zod");
+const errors_js_1 = require("../client/errors.js");
+const truncate_js_1 = require("../lib/truncate.js");
+// Conventions every tool follows:
+//   * `structuredContent` carries the typed result; `content[0].text` is the
+//     same JSON (compact) so clients without structured-output support see it.
+//   * Errors are never thrown to the client: they come back as
+//     `{ isError: true, structuredContent: { error: { code, message, hint, … } } }`
+//     with a hint the model can act on (which scope is missing, which
+//     candidates exist, what to call next).
+//   * Every tool takes an optional `workspace` (name or id) where it matters.
+const ok = (structured, text) => ({
+    content: [{ type: "text", text: text ?? (0, truncate_js_1.safeStringify)(structured) }],
+    structuredContent: structured,
+});
+exports.ok = ok;
+const toolFailure = (error) => {
+    let payload;
+    if (error instanceof errors_js_1.CallmanApiError) {
+        payload = {
+            code: error.code,
+            status: error.status,
+            message: error.message,
+            hint: (0, errors_js_1.hintFor)(error),
+            ...(error.details !== undefined ? { details: error.details } : {}),
+            request: `${error.method} ${error.path}`,
+        };
+    }
+    else if (error instanceof errors_js_1.ToolInputError) {
+        payload = { code: error.code, message: error.message, ...(error.data ?? {}) };
+    }
+    else if (error instanceof errors_js_1.CallmanNetworkError) {
+        payload = { code: "NETWORK_UNREACHABLE", message: error.message, apiUrl: error.apiUrl };
+    }
+    else {
+        payload = { code: "INTERNAL_ERROR", message: error instanceof Error ? error.message : String(error) };
+    }
+    const structured = { error: payload };
+    return { isError: true, content: [{ type: "text", text: (0, truncate_js_1.safeStringify)(structured) }], structuredContent: structured };
+};
+exports.toolFailure = toolFailure;
+const guarded = (fn) => async (args) => {
+    try {
+        return await fn(args);
+    }
+    catch (error) {
+        return (0, exports.toolFailure)(error);
+    }
+};
+exports.guarded = guarded;
+// ── annotations ────────────────────────────────────────────────────────
+exports.READ = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+exports.WRITE = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+exports.IDEMPOTENT_WRITE = { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+exports.DESTRUCTIVE = { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false };
+exports.RUN = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true };
+// ── shared argument schemas ────────────────────────────────────────────
+exports.workspaceArg = zod_1.z
+    .string()
+    .max(200)
+    .optional()
+    .describe("Workspace id or name. Defaults to CALLMAN_WORKSPACE_ID, or the only workspace you have; call list_workspaces to see them.");
+const refArg = (what, extra = "") => zod_1.z.string().min(1).max(500).describe(`${what} id or name${extra ? ` ${extra}` : ""}`);
+exports.refArg = refArg;
+exports.cursorArgs = {
+    cursor: zod_1.z.string().max(200).optional().describe("Pass the previous result's nextCursor to get the next page"),
+    limit: zod_1.z.number().int().min(1).max(truncate_js_1.LIMITS.LIST_MAX).optional().describe(`Page size (default ${truncate_js_1.LIMITS.LIST_DEFAULT})`),
+};
+exports.confirmArg = zod_1.z
+    .literal(true)
+    .describe("Must be exactly true. Confirms a permanent deletion — ask the user first unless they already asked for it explicitly.");
+exports.dryRunArg = zod_1.z.boolean().optional().describe("true = validate and preview only; nothing is written");
+const requireConfirm = (confirm, what) => {
+    if (confirm !== true) {
+        throw new errors_js_1.ToolInputError("CONFIRM_REQUIRED", `Deleting ${what} is permanent. Call again with confirm: true after the user agrees.`);
+    }
+};
+exports.requireConfirm = requireConfirm;

package/dist-cjs/tools/workspaces.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerWorkspaceTools = void 0;
+const zod_1 = require("zod");
+const errors_js_1 = require("../client/errors.js");
+const resolve_js_1 = require("../domain/resolve.js");
+const ids_js_1 = require("../lib/ids.js");
+const shared_js_1 = require("./shared.js");
+const registerWorkspaceTools = (server, ctx) => {
+    server.registerTool("list_workspaces", {
+        title: "List workspaces",
+        description: "List the workspaces you belong to, with your role in each (owner / editor / viewer). A token keeps your role: writes are refused where you are a viewer.",
+        inputSchema: {},
+        annotations: shared_js_1.READ,
+    }, (0, shared_js_1.guarded)(async () => {
+        const workspaces = await ctx.listWorkspaces();
+        return (0, shared_js_1.ok)({
+            workspaces: workspaces.map((workspace) => ({
+                id: workspace.id,
+                name: workspace.name,
+                role: workspace.role,
+                memberCount: workspace.memberCount ?? null,
+                isDefault: workspace.id === ctx.config.defaultWorkspaceId,
+            })),
+        });
+    }));
+    server.registerTool("list_workspace_members", {
+        title: "List workspace members",
+        description: "List the members of a workspace with their role and status (active / invited).",
+        inputSchema: { workspace: shared_js_1.workspaceArg },
+        annotations: shared_js_1.READ,
+    }, (0, shared_js_1.guarded)(async ({ workspace }) => {
+        const target = await ctx.resolveWorkspace(workspace);
+        const { items } = await ctx.api.listMembers(target.id);
+        return (0, shared_js_1.ok)({
+            workspace: { id: target.id, name: target.name },
+            members: items.map((member) => ({ id: member.id, userId: member.userId, email: member.email, role: member.role, status: member.status })),
+        });
+    }));
+    server.registerTool("add_workspace_member", {
+        title: "Add a workspace member",
+        description: "Add a person to a workspace by email with a role (editor can write collections/requests/scenarios; viewer is read-only; owner manages the workspace). Requires the owner role in that workspace. The person must already have a Callman account — the server does not send invitations to unknown emails.",
+        inputSchema: {
+            workspace: shared_js_1.workspaceArg,
+            email: zod_1.z.string().email().max(255),
+            role: zod_1.z.enum(["owner", "editor", "viewer"]).default("editor"),
+        },
+        annotations: shared_js_1.WRITE,
+    }, (0, shared_js_1.guarded)(async ({ workspace, email, role }) => {
+        const target = await ctx.resolveWorkspace(workspace);
+        const member = await ctx.api.addMember(target.id, { email: email.trim().toLowerCase(), role });
+        ctx.invalidate(`members:${target.id}`);
+        return (0, shared_js_1.ok)({
+            workspace: { id: target.id, name: target.name },
+            member: { id: member.id, email: member.email, role: member.role, status: member.status },
+            note: member.status === "invited" ? "Pending — the person gets access when they sign in." : "Added.",
+        });
+    }));
+    server.registerTool("remove_workspace_member", {
+        title: "Remove a workspace member",
+        description: "Remove a member from a workspace (by email or membership id). Requires the owner role. Permanent — confirm with the user first.",
+        inputSchema: {
+            workspace: shared_js_1.workspaceArg,
+            member: zod_1.z.string().min(1).max(255).describe("Member email or membership id"),
+            confirm: shared_js_1.confirmArg,
+        },
+        annotations: shared_js_1.DESTRUCTIVE,
+    }, (0, shared_js_1.guarded)(async ({ workspace, member, confirm }) => {
+        (0, shared_js_1.requireConfirm)(confirm, "a workspace member");
+        const target = await ctx.resolveWorkspace(workspace);
+        const { items } = await ctx.api.listMembers(target.id);
+        const needle = (0, ids_js_1.normalizeName)(member);
+        const byEmail = items.filter((entry) => (0, ids_js_1.normalizeName)(entry.email) === needle);
+        const resolved = byEmail.length === 1
+            ? byEmail[0]
+            : (0, resolve_js_1.resolveRef)("member", member, items.map((entry) => ({ ...entry, name: entry.email }))).item;
+        if (!resolved)
+            throw new errors_js_1.ToolInputError("REF_NOT_FOUND", `No member matches "${member}".`);
+        await ctx.api.removeMember(target.id, resolved.id);
+        return (0, shared_js_1.ok)({ workspace: { id: target.id, name: target.name }, removed: { id: resolved.id, email: resolved.email } });
+    }));
+};
+exports.registerWorkspaceTools = registerWorkspaceTools;

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "callman-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for Callman: lets Claude Code, Claude Desktop, Cursor, Codex and Gemini CLI manage collections, requests, environments, test scenarios and system-design diagrams in your Callman workspace — cloud or on-prem.",
+  "keywords": [
+    "callman",
+    "mcp",
+    "model-context-protocol",
+    "api",
+    "testing",
+    "claude",
+    "cursor",
+    "codex",
+    "gemini",
+    "postman"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/memmedov-karim/callman_mcp.git"
+  },
+  "homepage": "https://github.com/memmedov-karim/callman_mcp#readme",
+  "bugs": {
+    "url": "https://github.com/memmedov-karim/callman_mcp/issues"
+  },
+  "type": "module",
+  "bin": {
+    "callman-mcp": "./dist/index.js"
+  },
+  "main": "./dist-cjs/main.js",
+  "module": "./dist/main.js",
+  "types": "./dist/main.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/main.d.ts",
+      "import": "./dist/main.js",
+      "require": "./dist-cjs/main.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "dist-cjs",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build:resources": "node scripts/build-static-resources.mjs",
+    "build": "npm run build:resources && tsc -p tsconfig.json && tsc -p tsconfig.cjs.json && node scripts/postbuild.mjs",
+    "typecheck": "tsc -p tsconfig.test.json",
+    "lint": "eslint . && npm run typecheck",
+    "test": "vitest run",
+    "smoke": "node scripts/smoke.mjs",
+    "doctor": "node dist/index.js doctor",
+    "prepublishOnly": "npm run lint && npm run build && npm test && npm run smoke"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "callman-core": "^1.28.0",
+    "elkjs": "^0.12.0",
+    "js-yaml": "^4.1.0",
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.5",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^22.10.2",
+    "eslint": "^9.39.5",
+    "globals": "^16.5.0",
+    "typescript": "^5.7.2",
+    "typescript-eslint": "^8.70.0",
+    "vitest": "^4.1.10"
+  }
+}