callman-mcp 0.1.0 → 0.2.0

package/dist-cjs/tools/environments.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerEnvironmentTools = void 0;
 const zod_1 = require("zod");
 const errors_js_1 = require("../client/errors.js");
-const requestShape_js_1 = require("../domain/requestShape.js");
 const resolve_js_1 = require("../domain/resolve.js");
 const mask_js_1 = require("../lib/mask.js");
+const strict_js_1 = require("../lib/strict.js");
 const truncate_js_1 = require("../lib/truncate.js");
 const lookups_js_1 = require("./lookups.js");
 const shared_js_1 = require("./shared.js");
@@ -14,98 +14,163 @@ const shared_js_1 = require("./shared.js");
 // environments:reveal AND the call asks for reveal — the server enforces
 // both; this side only forwards the flag and refuses to write a masked
 // value back.
+// An environment variable is exactly { key, value } on the server — no
+// enabled flag, no description (strict: sending them is an error, not a no-op).
+const VARIABLES_MAX = 500;
+const variableSchema = (0, strict_js_1.strictObject)({
+    key: zod_1.z.string().trim().min(1).max(100),
+    value: zod_1.z.string().max(5000).default(""),
+}, "variable field");
+const refuseMasked = (variables, action) => {
+    const maskedKeys = variables.filter((variable) => (0, mask_js_1.isMasked)(variable.value)).map((variable) => variable.key);
+    if (maskedKeys.length > 0) {
+        throw new errors_js_1.ToolInputError("MASKED_VALUE", `Masked values cannot be ${action} (keys: ${maskedKeys.join(", ")}). Read them with get_environment reveal: true (needs environments:reveal) or supply the real values.`, { keys: maskedKeys });
+    }
+};
+const duplicateKeys = (variables) => {
+    const seen = new Set();
+    const duplicates = new Set();
+    for (const variable of variables)
+        (seen.has(variable.key) ? duplicates : seen).add(variable.key);
+    return [...duplicates];
+};
+// Global variables are optional (feature flag, scope) — say why they are
+// missing instead of returning an empty list as if there were none.
+const loadGlobals = async (ctx, ws, reveal) => {
+    try {
+        return { globals: await ctx.api.listGlobalVariables(ws, reveal) };
+    }
+    catch (error) {
+        return { globals: [], globalVariablesError: (0, shared_js_1.toolFailure)(error).structuredContent.error };
+    }
+};
 const registerEnvironmentTools = (server, ctx) => {
     server.registerTool("list_environments", {
         title: "List environments",
-        description: "List a workspace's environments with their variable KEYS (values are not included). Global variables (shared by every environment) are listed too.",
+        description: "List environments with their variable KEYS (values are not included) — across ALL your workspaces unless `workspace` narrows it, each workspace with its global variables (shared by that workspace's environments).",
         inputSchema: { workspace: shared_js_1.workspaceArg },
         annotations: shared_js_1.READ,
     }, (0, shared_js_1.guarded)(async ({ workspace }) => {
-        const ws = await ctx.resolveWorkspace(workspace);
-        const [environments, globals] = await Promise.all([
-            (0, lookups_js_1.loadEnvironments)(ctx, ws.id),
-            ctx.api.listGlobalVariables(ws.id).catch(() => []),
-        ]);
-        return (0, shared_js_1.ok)({
-            workspace: { id: ws.id, name: ws.name },
-            environments: environments.map((environment) => ({
-                id: environment.id,
-                name: environment.name,
-                variableCount: environment.variables.length,
-                variableKeys: environment.variables.map((variable) => variable.key).slice(0, 200),
-            })),
-            globalVariableKeys: globals.map((variable) => variable.key),
-        });
+        const workspaces = await (0, lookups_js_1.workspacesForListing)(ctx, workspace);
+        const perWorkspace = await Promise.all(workspaces.map(async (ws) => {
+            const [environments, globals] = await Promise.all([(0, lookups_js_1.loadEnvironments)(ctx, ws.id), loadGlobals(ctx, ws.id, false)]);
+            return {
+                workspace: (0, lookups_js_1.workspaceTag)(ws),
+                environments: environments.map((environment) => ({
+                    id: environment.id,
+                    name: environment.name,
+                    variableCount: environment.variables.length,
+                    variableKeys: environment.variables.map((variable) => variable.key).slice(0, 200),
+                    ...(environment.variables.length > 200 ? { variableKeysTruncated: true } : {}),
+                })),
+                globalVariableKeys: globals.globals.map((variable) => variable.key),
+                ...(globals.globalVariablesError ? { globalVariablesError: globals.globalVariablesError } : {}),
+            };
+        }));
+        // One workspace keeps the flat shape; several come back per workspace.
+        return (0, shared_js_1.ok)(perWorkspace.length === 1 ? perWorkspace[0] : { workspaces: perWorkspace });
     }));
     server.registerTool("get_environment", {
         title: "Get an environment",
-        description: "Read one environment's variables. Values are masked (••••ab) unless reveal: true AND the token holds environments:reveal. Global variables are returned alongside.",
+        description: "Read one environment's variables ({ key, value }). Values are masked (••••ab) unless reveal: true AND the token holds environments:reveal. Global variables are returned alongside.",
         inputSchema: { workspace: shared_js_1.workspaceArg, environment: (0, shared_js_1.refArg)("Environment"), reveal: zod_1.z.boolean().optional() },
         annotations: shared_js_1.READ,
     }, (0, shared_js_1.guarded)(async ({ workspace, environment, reveal }) => {
-        const ws = await ctx.resolveWorkspace(workspace);
-        const resolved = await (0, lookups_js_1.resolveEnvironment)(ctx, ws.id, environment);
-        const [fresh, globals] = await Promise.all([
-            ctx.api.getEnvironment(ws.id, resolved.item.id, reveal ?? false),
-            ctx.api.listGlobalVariables(ws.id, reveal ?? false).catch(() => []),
-        ]);
+        const { ws, value: resolved, note } = await (0, lookups_js_1.findEnvironment)(ctx, workspace, environment);
+        const [fresh, globals] = await Promise.all([ctx.api.getEnvironment(ws.id, resolved.item.id, reveal ?? false), loadGlobals(ctx, ws.id, reveal ?? false)]);
         const masked = fresh.variables.some((variable) => variable.valueMasked);
         return (0, shared_js_1.ok)({
-            environment: {
-                id: fresh.id,
-                name: fresh.name,
-                variables: fresh.variables.map((variable) => ({ key: variable.key, value: variable.value, ...(variable.enabled === false ? { enabled: false } : {}) })),
-            },
-            globalVariables: globals.map((variable) => ({ key: variable.key, value: variable.value })),
+            environment: { id: fresh.id, name: fresh.name, variables: fresh.variables.map((variable) => ({ key: variable.key, value: variable.value })) },
+            workspace: (0, lookups_js_1.workspaceTag)(ws),
+            globalVariables: globals.globals.map((variable) => ({ key: variable.key, value: variable.value })),
+            ...(globals.globalVariablesError ? { globalVariablesError: globals.globalVariablesError } : {}),
             valuesMasked: masked,
             ...(masked && reveal ? { note: "Values stayed masked: the token lacks environments:reveal." } : {}),
-            resolved: [(0, resolve_js_1.resolvedSummary)(environment, resolved)],
+            resolved: [(0, resolve_js_1.resolvedSummary)(environment, resolved), ...(note ? [{ input: environment, note }] : [])],
         });
     }));
     server.registerTool("create_environment", {
         title: "Create an environment",
-        description: "Create an environment with optional variables (key/value). Use it for hosts ({{baseUrl}}) and credentials so requests never hard-code them.",
+        description: `Create an environment with variables ({ key, value }, up to ${VARIABLES_MAX}) in \`workspace\` (or the session default — use_workspace). Use it for hosts ({{baseUrl}}) and credentials so requests never hard-code them; requests use environments of their own workspace. Names must be unique in the workspace.`,
         inputSchema: {
             workspace: shared_js_1.workspaceArg,
-            name: zod_1.z.string().min(1).max(truncate_js_1.LIMITS.NAME),
-            variables: zod_1.z.array(requestShape_js_1.kvSchema).max(500).optional(),
+            name: zod_1.z.string().trim().min(1).max(truncate_js_1.LIMITS.NAME),
+            variables: zod_1.z.array(variableSchema).max(VARIABLES_MAX).optional(),
         },
         annotations: shared_js_1.WRITE,
     }, (0, shared_js_1.guarded)(async ({ workspace, name, variables }) => {
         const ws = await ctx.resolveWorkspace(workspace);
-        const rows = (0, requestShape_js_1.toRows)(variables);
-        const maskedKeys = rows.filter((row) => (0, mask_js_1.isMasked)(row.value)).map((row) => row.key);
-        if (maskedKeys.length > 0)
-            throw new errors_js_1.ToolInputError("MASKED_VALUE", `Masked values cannot be stored (keys: ${maskedKeys.join(", ")}). Provide the real values.`);
+        const rows = variables ?? [];
+        refuseMasked(rows, "stored");
+        const duplicates = duplicateKeys(rows);
+        if (duplicates.length > 0)
+            throw new errors_js_1.ToolInputError("DUPLICATE_KEYS", `Each key once: ${duplicates.join(", ")}.`);
+        const existing = (await (0, lookups_js_1.loadEnvironments)(ctx, ws.id)).find((entry) => (0, lookups_js_1.sameName)(entry.name, name));
+        if (existing) {
+            throw new errors_js_1.ToolInputError("ENVIRONMENT_NAME_EXISTS", `An environment named "${existing.name}" already exists (id ${existing.id}) — use set_environment_variables on it, or pick another name.`, { existing: { id: existing.id, name: existing.name } });
+        }
         const created = await ctx.api.createEnvironment(ws.id, { name: name.trim(), variables: rows });
         ctx.invalidate(`environments:${ws.id}`);
-        return (0, shared_js_1.ok)({ environment: { id: created.id, name: created.name, variableKeys: created.variables.map((variable) => variable.key) } });
+        return (0, shared_js_1.ok)({ environment: { id: created.id, name: created.name, variableKeys: created.variables.map((variable) => variable.key) }, workspace: (0, lookups_js_1.workspaceTag)(ws) });
+    }));
+    server.registerTool("update_environment", {
+        title: "Rename an environment",
+        description: "Rename an environment. (Change its variables with set_environment_variables.)",
+        inputSchema: { workspace: shared_js_1.workspaceArg, environment: (0, shared_js_1.refArg)("Environment"), name: zod_1.z.string().trim().min(1).max(truncate_js_1.LIMITS.NAME) },
+        annotations: shared_js_1.IDEMPOTENT_WRITE,
+    }, (0, shared_js_1.guarded)(async ({ workspace, environment, name }) => {
+        const { ws, value: resolved } = await (0, lookups_js_1.findEnvironment)(ctx, workspace, environment);
+        const clash = (await (0, lookups_js_1.loadEnvironments)(ctx, ws.id)).find((entry) => entry.id !== resolved.item.id && (0, lookups_js_1.sameName)(entry.name, name));
+        if (clash)
+            throw new errors_js_1.ToolInputError("ENVIRONMENT_NAME_EXISTS", `Another environment is already named "${clash.name}".`);
+        const updated = await ctx.api.updateEnvironment(ws.id, resolved.item.id, { name: name.trim() });
+        ctx.invalidate(`environments:${ws.id}`);
+        return (0, shared_js_1.ok)({ environment: { id: updated.id, name: updated.name, previousName: resolved.item.name }, workspace: (0, lookups_js_1.workspaceTag)(ws), resolved: [(0, resolve_js_1.resolvedSummary)(environment, resolved)] });
     }));
     server.registerTool("set_environment_variables", {
-        title: "Set / unset environment variables",
-        description: "Upsert variables (`set`) and/or remove keys (`unset`) in an environment. Existing keys are updated in place, new keys appended, other keys untouched. A masked value (starting with ••••) is refused — read it with reveal or supply a real value.",
+        title: "Set / rename / unset environment variables",
+        description: "Change an environment's variables: `set` upserts ({ key, value } — existing keys updated in place, new keys appended), `rename` changes keys keeping their values, `unset` removes keys (needs environments:delete). Other keys are untouched. A masked value (••••…) is refused — read it with reveal or supply a real value. Reports what changed, what failed (with the error code) and unset keys that did not exist.",
         inputSchema: {
             workspace: shared_js_1.workspaceArg,
             environment: (0, shared_js_1.refArg)("Environment"),
-            set: zod_1.z.array(requestShape_js_1.kvSchema).max(500).optional(),
-            unset: zod_1.z.array(zod_1.z.string().min(1).max(100)).max(500).optional(),
+            set: zod_1.z.array(variableSchema).max(VARIABLES_MAX).optional(),
+            rename: zod_1.z.array((0, strict_js_1.strictObject)({ from: zod_1.z.string().trim().min(1).max(100), to: zod_1.z.string().trim().min(1).max(100) }, "rename field")).max(VARIABLES_MAX).optional(),
+            unset: zod_1.z.array(zod_1.z.string().trim().min(1).max(100)).max(VARIABLES_MAX).optional(),
         },
         annotations: shared_js_1.IDEMPOTENT_WRITE,
-    }, (0, shared_js_1.guarded)(async ({ workspace, environment, set, unset }) => {
-        const rows = (0, requestShape_js_1.toRows)(set);
-        const removals = (unset ?? []).map((key) => key.trim()).filter(Boolean);
-        if (rows.length === 0 && removals.length === 0)
-            throw new errors_js_1.ToolInputError("NOTHING_TO_UPDATE", "Pass set and/or unset.");
-        const maskedKeys = rows.filter((row) => (0, mask_js_1.isMasked)(row.value)).map((row) => row.key);
-        if (maskedKeys.length > 0)
-            throw new errors_js_1.ToolInputError("MASKED_VALUE", `Masked values cannot be written back (keys: ${maskedKeys.join(", ")}).`);
-        const ws = await ctx.resolveWorkspace(workspace);
-        const resolved = await (0, lookups_js_1.resolveEnvironment)(ctx, ws.id, environment);
+    }, (0, shared_js_1.guarded)(async ({ workspace, environment, set, rename, unset }) => {
+        const rows = set ?? [];
+        const renames = rename ?? [];
+        const removals = unset ?? [];
+        if (rows.length === 0 && renames.length === 0 && removals.length === 0)
+            throw new errors_js_1.ToolInputError("NOTHING_TO_UPDATE", "Pass set, rename and/or unset.");
+        refuseMasked(rows, "written back");
+        const duplicates = duplicateKeys(rows);
+        if (duplicates.length > 0)
+            throw new errors_js_1.ToolInputError("DUPLICATE_KEYS", `Each key once in set: ${duplicates.join(", ")}.`);
+        const { ws, value: resolved } = await (0, lookups_js_1.findEnvironment)(ctx, workspace, environment);
         const existingKeys = new Set(resolved.item.variables.map((variable) => variable.key));
         const updated = [];
         const added = [];
+        const renamed = [];
         const removed = [];
+        const notFound = [];
         const failed = [];
+        for (const { from, to } of renames) {
+            if (!existingKeys.has(from)) {
+                notFound.push(from);
+                continue;
+            }
+            try {
+                await ctx.api.updateEnvironmentVariable(ws.id, resolved.item.id, from, { key: to });
+                existingKeys.delete(from);
+                existingKeys.add(to);
+                renamed.push({ from, to });
+            }
+            catch (error) {
+                failed.push({ key: from, error: (0, shared_js_1.failureOf)(error) });
+            }
+        }
         for (const row of rows) {
             try {
                 if (existingKeys.has(row.key)) {
@@ -119,35 +184,90 @@ const registerEnvironmentTools = (server, ctx) => {
                 }
             }
             catch (error) {
-                failed.push({ key: row.key, error: error instanceof Error ? error.message : String(error) });
+                failed.push({ key: row.key, error: (0, shared_js_1.failureOf)(error) });
             }
         }
         for (const key of removals) {
+            if (!existingKeys.has(key)) {
+                notFound.push(key);
+                continue;
+            }
             try {
-                if (!existingKeys.has(key))
-                    continue;
                 await ctx.api.deleteEnvironmentVariable(ws.id, resolved.item.id, key);
                 removed.push(key);
             }
             catch (error) {
-                failed.push({ key, error: error instanceof Error ? error.message : String(error) });
+                failed.push({ key, error: (0, shared_js_1.failureOf)(error) });
             }
         }
         ctx.invalidate(`environments:${ws.id}`);
-        return (0, shared_js_1.ok)({ environment: { id: resolved.item.id, name: resolved.item.name }, updated, added, removed, failed, resolved: [(0, resolve_js_1.resolvedSummary)(environment, resolved)] });
+        const changed = updated.length + added.length + renamed.length + removed.length;
+        const body = { environment: { id: resolved.item.id, name: resolved.item.name }, workspace: (0, lookups_js_1.workspaceTag)(ws), updated, added, renamed, removed, notFound, failed, resolved: [(0, resolve_js_1.resolvedSummary)(environment, resolved)] };
+        if (failed.length > 0 && changed === 0) {
+            return { ...(0, shared_js_1.toolFailure)(new errors_js_1.ToolInputError("NOTHING_CHANGED", `No variable was changed — every write failed (first: ${String(failed[0].error.code ?? failed[0].error.message)}).`, body)) };
+        }
+        return (0, shared_js_1.ok)({ ...body, ...(failed.length > 0 ? { partial: true } : {}) });
+    }));
+    server.registerTool("set_global_variables", {
+        title: "Set / unset global variables",
+        description: "Upsert (`set`: { key, value }) and/or remove (`unset`, needs environments:delete) the GLOBAL variables of `workspace` (or the session default) — shared by that workspace's environments and resolved as {{key}} when no environment defines it, or explicitly as {{global.key}}. A masked value (••••…) is refused.",
+        inputSchema: {
+            workspace: shared_js_1.workspaceArg,
+            set: zod_1.z.array(variableSchema).max(VARIABLES_MAX).optional(),
+            unset: zod_1.z.array(zod_1.z.string().trim().min(1).max(100)).max(VARIABLES_MAX).optional(),
+        },
+        annotations: shared_js_1.IDEMPOTENT_WRITE,
+    }, (0, shared_js_1.guarded)(async ({ workspace, set, unset }) => {
+        const rows = set ?? [];
+        const removals = unset ?? [];
+        if (rows.length === 0 && removals.length === 0)
+            throw new errors_js_1.ToolInputError("NOTHING_TO_UPDATE", "Pass set and/or unset.");
+        refuseMasked(rows, "written back");
+        const ws = await ctx.resolveWorkspace(workspace);
+        const existing = new Set((await ctx.api.listGlobalVariables(ws.id)).map((variable) => variable.key));
+        const written = [];
+        const removed = [];
+        const notFound = [];
+        const failed = [];
+        for (const row of rows) {
+            try {
+                await ctx.api.setGlobalVariable(ws.id, { key: row.key, value: row.value });
+                written.push(row.key);
+            }
+            catch (error) {
+                failed.push({ key: row.key, error: (0, shared_js_1.failureOf)(error) });
+            }
+        }
+        for (const key of removals) {
+            if (!existing.has(key)) {
+                notFound.push(key);
+                continue;
+            }
+            try {
+                await ctx.api.deleteGlobalVariable(ws.id, key);
+                removed.push(key);
+            }
+            catch (error) {
+                failed.push({ key, error: (0, shared_js_1.failureOf)(error) });
+            }
+        }
+        const body = { workspace: { id: ws.id, name: ws.name }, written, removed, notFound, failed };
+        if (failed.length > 0 && written.length + removed.length === 0) {
+            return (0, shared_js_1.toolFailure)(new errors_js_1.ToolInputError("NOTHING_CHANGED", `No global variable was changed — every write failed (first: ${String(failed[0].error.code ?? failed[0].error.message)}).`, body));
+        }
+        return (0, shared_js_1.ok)({ ...body, ...(failed.length > 0 ? { partial: true } : {}) });
     }));
     server.registerTool("delete_environment", {
         title: "Delete an environment",
-        description: "Delete an environment and all its variables. Permanent — confirm with the user first.",
+        description: "Delete an environment and all its variables (exact name or id). Permanent — confirm with the user first.",
         inputSchema: { workspace: shared_js_1.workspaceArg, environment: (0, shared_js_1.refArg)("Environment"), confirm: shared_js_1.confirmArg },
         annotations: shared_js_1.DESTRUCTIVE,
     }, (0, shared_js_1.guarded)(async ({ workspace, environment, confirm }) => {
         (0, shared_js_1.requireConfirm)(confirm, "an environment");
-        const ws = await ctx.resolveWorkspace(workspace);
-        const resolved = await (0, lookups_js_1.resolveEnvironment)(ctx, ws.id, environment);
+        const { ws, value: resolved } = await (0, lookups_js_1.findEnvironment)(ctx, workspace, environment, { exact: true });
         await ctx.api.deleteEnvironment(ws.id, resolved.item.id);
         ctx.invalidate(`environments:${ws.id}`);
-        return (0, shared_js_1.ok)({ deleted: { id: resolved.item.id, name: resolved.item.name }, resolved: [(0, resolve_js_1.resolvedSummary)(environment, resolved)] });
+        return (0, shared_js_1.ok)({ deleted: { id: resolved.item.id, name: resolved.item.name }, workspace: (0, lookups_js_1.workspaceTag)(ws), resolved: [(0, resolve_js_1.resolvedSummary)(environment, resolved)] });
     }));
 };
 exports.registerEnvironmentTools = registerEnvironmentTools;

package/dist-cjs/tools/import.js

@@ -7,6 +7,7 @@ const errors_js_1 = require("../client/errors.js");
 const importDetect_js_1 = require("../domain/importDetect.js");
 const resolve_js_1 = require("../domain/resolve.js");
 const truncate_js_1 = require("../lib/truncate.js");
+const strict_js_1 = require("../lib/strict.js");
 const lookups_js_1 = require("./lookups.js");
 const shared_js_1 = require("./shared.js");
 const CONTENT_MAX = 8 * 1024 * 1024;
@@ -14,7 +15,7 @@ const IMPORT_FORMATS = ["auto", "postman", "openapi", "insomnia", "bruno", "inte
 const registerImportTools = (server, ctx) => {
     server.registerTool("import_content", {
         title: "Import a file's content",
-        description: "Import API definitions from file CONTENT you read: Postman collection, OpenAPI/Swagger (JSON or YAML), Insomnia, Bruno, a Callman export, a cURL script, or a .http/.rest file. The format is detected (`format: auto`). Document formats always create a new collection; cURL/.http create a new collection (`collectionName`) or add to an existing one (`targetCollection` + optional `folder`). Use dryRun: true to see what was detected before writing. For endpoints found in source code, read the routes yourself and call create_requests_bulk instead.",
+        description: "Import API definitions from file CONTENT you read: Postman collection, OpenAPI/Swagger (JSON or YAML), Insomnia, Bruno, a Callman export, a cURL script, or a .http/.rest file. The format is detected (`format: auto`). Document formats always create a new collection; cURL/.http create a new collection (`collectionName`) or add to an existing one (`targetCollection` + optional `folder`). Variables the file defines (Postman collection variables, OpenAPI servers → baseUrl, .http @vars) are written into `environment` when you name one — without it, requests reference {{variables}} that have no value anywhere. Use dryRun: true to see what was detected before writing. For endpoints found in source code, read the routes yourself and call create_requests_bulk instead.",
         inputSchema: {
             workspace: shared_js_1.workspaceArg,
             content: zod_1.z.string().min(1).max(CONTENT_MAX).describe("The raw file content"),
@@ -23,13 +24,21 @@ const registerImportTools = (server, ctx) => {
             collectionName: zod_1.z.string().max(truncate_js_1.LIMITS.NAME).optional().describe("Name for the new collection (documents: fallback when the file carries no name)"),
             targetCollection: zod_1.z.string().max(200).optional().describe("cURL/.http only: add to this existing collection instead of creating one"),
             folder: zod_1.z.string().max(300).optional().describe("cURL/.http + targetCollection: folder to put the requests in"),
+            environment: zod_1.z.string().max(200).optional().describe("Environment (id or name) that receives the variables the file defines"),
             dryRun: shared_js_1.dryRunArg,
         },
         annotations: shared_js_1.WRITE,
-    }, (0, shared_js_1.guarded)(async ({ workspace, content, fileName, format, collectionName, targetCollection, folder, dryRun }) => {
-        const ws = await ctx.resolveWorkspace(workspace);
+    }, (0, shared_js_1.guarded)(async ({ workspace, content, fileName, format, collectionName, targetCollection, folder, environment, dryRun }) => {
+        // Into an existing collection → that collection's workspace; otherwise
+        // the one named, the session default or the only one.
+        const target = targetCollection ? await (0, lookups_js_1.findCollection)(ctx, workspace, targetCollection) : null;
+        const ws = target ? target.ws : await ctx.resolveWorkspace(workspace);
         const detection = (0, importDetect_js_1.detectImport)(fileName, content);
         const resolvedFormat = format === "auto" ? detection.format : format;
+        const targetEnvironment = environment ? await (0, lookups_js_1.resolveEnvironment)(ctx, ws.id, environment) : null;
+        if (folder && !targetCollection) {
+            throw new errors_js_1.ToolInputError("FOLDER_NEEDS_TARGET_COLLECTION", "`folder` only applies together with targetCollection (cURL/.http into an existing collection).");
+        }
         if (resolvedFormat === "unknown" || resolvedFormat === "scenario" || resolvedFormat === "environment") {
             throw new errors_js_1.ToolInputError("IMPORT_FORMAT_UNSUPPORTED", resolvedFormat === "scenario"
                 ? "This is a Callman scenario export — use import_scenario."
@@ -49,8 +58,28 @@ const registerImportTools = (server, ctx) => {
             if (collectionName)
                 payload = { ...payload, collectionName: collectionName.trim() };
             const sample = payload.requests.slice(0, 5).map((request) => `${request.method} ${request.name}`);
+            // .http `@name = value` lines (callman-core ≥ 1.28.1 returns them).
+            const fileVariables = (payload.variables ?? []).filter((variable) => variable.key);
+            const applyFileVariables = async () => {
+                if (fileVariables.length === 0)
+                    return {};
+                if (!targetEnvironment) {
+                    return { fileVariables: fileVariables.map((variable) => variable.key), fileVariablesNote: "The file defines these variables; pass `environment` to store them, or set them with set_environment_variables." };
+                }
+                const existing = new Set(targetEnvironment.item.variables.map((variable) => variable.key));
+                const written = [];
+                for (const variable of fileVariables) {
+                    if (existing.has(variable.key))
+                        await ctx.api.updateEnvironmentVariable(ws.id, targetEnvironment.item.id, variable.key, { value: variable.value });
+                    else
+                        await ctx.api.addEnvironmentVariable(ws.id, targetEnvironment.item.id, { key: variable.key, value: variable.value });
+                    written.push(variable.key);
+                }
+                ctx.invalidate(`environments:${ws.id}`);
+                return { environment: { id: targetEnvironment.item.id, name: targetEnvironment.item.name, variablesWritten: written } };
+            };
             if (targetCollection) {
-                const resolved = await (0, lookups_js_1.resolveCollection)(ctx, ws.id, targetCollection);
+                const resolved = target.value;
                 const targetFolder = await (0, lookups_js_1.resolveFolder)(ctx, ws.id, resolved.item.id, folder);
                 if (dryRun) {
                     return (0, shared_js_1.ok)({ dryRun: true, detected: detection, format: resolvedFormat, mode: "existing-collection", collection: { id: resolved.item.id, name: resolved.item.name }, requestCount: payload.requests.length, sample });
@@ -63,12 +92,12 @@ const registerImportTools = (server, ctx) => {
                         created.push({ id: row.id, name: row.name, method: row.method });
                     }
                     catch (error) {
-                        failed.push({ name: request.name, error: error instanceof errors_js_1.CallmanApiError ? `${error.code}: ${error.message}` : String(error) });
+                        failed.push({ name: request.name, error: (0, shared_js_1.failureOf)(error) });
                     }
                 }
                 ctx.invalidate(`tree:${ws.id}:${resolved.item.id}`);
                 ctx.invalidate(`collections:${ws.id}`);
-                return (0, shared_js_1.ok)({ format: resolvedFormat, collection: { id: resolved.item.id, name: resolved.item.name }, created: created.length, failed, requests: created, resolved: [(0, resolve_js_1.resolvedSummary)(targetCollection, resolved)] });
+                return (0, shared_js_1.ok)({ format: resolvedFormat, collection: { id: resolved.item.id, name: resolved.item.name }, workspace: (0, lookups_js_1.workspaceTag)(ws), created: created.length, failed, requests: created, ...(await applyFileVariables()), resolved: [(0, resolve_js_1.resolvedSummary)(targetCollection, resolved)] });
             }
             const existing = (await (0, lookups_js_1.loadCollections)(ctx, ws.id)).find((entry) => (0, lookups_js_1.sameName)(entry.name, payload.collectionName));
             if (existing) {
@@ -81,7 +110,10 @@ const registerImportTools = (server, ctx) => {
             }
             const result = await ctx.api.importJson(ws.id, { format: "requests", payload });
             ctx.invalidate(`collections:${ws.id}`);
-            return (0, shared_js_1.ok)({ format: resolvedFormat, collection: { id: result.collection.id, name: result.collection.name }, created: result.importedCounts });
+            return (0, shared_js_1.ok)({ format: resolvedFormat, collection: { id: result.collection.id, name: result.collection.name }, workspace: (0, lookups_js_1.workspaceTag)(ws), created: result.importedCounts, ...(await applyFileVariables()) });
+        }
+        if (targetCollection) {
+            throw new errors_js_1.ToolInputError("IMPORT_TARGET_UNSUPPORTED", `A ${resolvedFormat} document always creates a new collection — targetCollection only applies to cURL/.http. Import it, then use move_requests to move requests into "${targetCollection}".`);
         }
         if (!importDetect_js_1.SERVER_DOCUMENT_FORMATS.has(resolvedFormat)) {
             throw new errors_js_1.ToolInputError("IMPORT_FORMAT_UNSUPPORTED", `Format "${resolvedFormat}" is not importable here.`);
@@ -90,22 +122,45 @@ const registerImportTools = (server, ctx) => {
         if (dryRun) {
             return (0, shared_js_1.ok)({ dryRun: true, detected: detection, format: resolvedFormat, mode: "new-collection", note: "The server parses this document; request counts are known after the import." });
         }
-        const result = await ctx.api.importJson(ws.id, { format: resolvedFormat, payload, ...(collectionName ? { fallbackCollectionName: collectionName.trim() } : {}) });
+        const result = await ctx.api.importJson(ws.id, {
+            format: resolvedFormat,
+            payload,
+            ...(collectionName ? { fallbackCollectionName: collectionName.trim() } : {}),
+            ...(targetEnvironment ? { targetEnvironmentId: targetEnvironment.item.id } : {}),
+        });
         ctx.invalidate(`collections:${ws.id}`);
-        return (0, shared_js_1.ok)({ format: resolvedFormat, collection: { id: result.collection.id, name: result.collection.name }, created: result.importedCounts });
+        if (targetEnvironment)
+            ctx.invalidate(`environments:${ws.id}`);
+        return (0, shared_js_1.ok)({
+            format: resolvedFormat,
+            collection: { id: result.collection.id, name: result.collection.name },
+            workspace: (0, lookups_js_1.workspaceTag)(ws),
+            created: result.importedCounts,
+            // Keys only — the import response carries the environment's values.
+            ...(result.environment ? { environment: { id: result.environment.id, name: result.environment.name, variableKeys: (result.environment.variables ?? []).map((variable) => variable.key) } } : {}),
+            ...(!targetEnvironment ? { note: "Variables defined by the file were not stored — pass `environment` to write them into an environment." } : {}),
+        });
     }));
     server.registerTool("import_scenario", {
         title: "Import a scenario export",
-        description: "Import a Callman scenario export (a `callman.scenario` envelope — the JSON of a .callman.scenario file, as text or object). Connections referenced by the export that have no counterpart here are skipped (the nodes import without a connection; the result lists warnings).",
+        description: "Import a Callman scenario export (a `callman.scenario` envelope — the JSON of a .callman.scenario file, as text or object). Connections the export references are matched to this workspace's connections of the same type and name automatically; `connections` overrides that per export connection (a workspace connection id or name, or \"skip\"). Unmatched ones are skipped (the nodes import without a connection) and listed. On-prem, `group` picks the scenario group.",
         inputSchema: {
             workspace: shared_js_1.workspaceArg,
             envelope: zod_1.z.union([zod_1.z.string().max(CONTENT_MAX), zod_1.z.record(zod_1.z.unknown())]).describe("The export envelope (JSON text or object)"),
             name: zod_1.z.string().max(200).optional().describe("Override the imported scenario's name"),
             folder: zod_1.z.string().max(200).optional().describe("Scenario folder id or name"),
+            group: zod_1.z.string().max(200).optional().describe('On-prem scenario group (name or id, or "personal")'),
+            connections: zod_1.z
+                .array((0, strict_js_1.strictObject)({
+                from: zod_1.z.string().min(1).max(300).describe("The export's connection (its refId or name)"),
+                to: zod_1.z.string().min(1).max(200).describe('Workspace connection id or name, or "skip"'),
+            }, "connection mapping field"))
+                .max(200)
+                .optional(),
             dryRun: shared_js_1.dryRunArg,
         },
         annotations: shared_js_1.WRITE,
-    }, (0, shared_js_1.guarded)(async ({ workspace, envelope, name, folder, dryRun }) => {
+    }, (0, shared_js_1.guarded)(async ({ workspace, envelope, name, folder, group, connections: mapping, dryRun }) => {
         const ws = await ctx.resolveWorkspace(workspace);
         let parsed = envelope;
         if (typeof envelope === "string") {
@@ -121,23 +176,59 @@ const registerImportTools = (server, ctx) => {
             throw new errors_js_1.ToolInputError("IMPORT_NOT_SCENARIO", "This is not a Callman scenario export (expected kind: \"callman.scenario\").");
         }
         const targetFolder = folder ? await (0, lookups_js_1.resolveScenarioFolder)(ctx, ws.id, folder) : null;
-        const connections = record.connections ?? [];
-        const connectionMap = Object.fromEntries(connections.filter((connection) => connection.refId).map((connection) => [connection.refId, { action: "skip" }]));
+        let groupId;
+        if (group) {
+            if (group.trim().toLowerCase() === "personal")
+                groupId = "personal";
+            else {
+                const { items } = await ctx.api.listMyScenarioGroups(ws.id);
+                if (items.length > 0)
+                    groupId = (0, resolve_js_1.resolveRef)("scenario group", group, items).item.id;
+            }
+        }
+        const exported = (record.connections ?? []).filter((connection) => connection.refId);
+        for (const entry of mapping ?? []) {
+            if (!exported.some((connection) => connection.refId === entry.from || connection.name === entry.from)) {
+                throw new errors_js_1.ToolInputError("IMPORT_CONNECTION_UNKNOWN", `The export has no connection "${entry.from}".`, { exportConnections: exported.map((connection) => ({ refId: connection.refId, name: connection.name, type: connection.type })) });
+            }
+        }
+        const available = exported.length > 0 ? await (0, lookups_js_1.loadConnections)(ctx, ws.id) : [];
+        const decisions = [];
+        const connectionMap = {};
+        for (const connection of exported) {
+            const override = (mapping ?? []).find((entry) => entry.from === connection.refId || entry.from === connection.name);
+            let target;
+            if (override && override.to.trim().toLowerCase() !== "skip") {
+                target = available.find((candidate) => candidate.id === override.to) ?? available.find((candidate) => candidate.name.toLowerCase() === override.to.toLowerCase());
+                if (!target)
+                    throw new errors_js_1.ToolInputError("CONNECTION_NOT_FOUND", `No workspace connection "${override.to}" (list_connections shows them).`);
+                if (connection.type && target.type !== connection.type)
+                    throw new errors_js_1.ToolInputError("CONNECTION_WRONG_TYPE", `"${target.name}" is a ${target.type} connection; the export's "${connection.name}" is ${connection.type}.`);
+            }
+            else if (!override) {
+                const sameName = available.filter((candidate) => candidate.type === connection.type && candidate.name.toLowerCase() === (connection.name ?? "").toLowerCase());
+                target = sameName.length === 1 ? sameName[0] : undefined;
+            }
+            connectionMap[connection.refId] = target ? { action: "map", connectionId: target.id } : { action: "skip" };
+            decisions.push({ export: connection.name ?? connection.refId, type: connection.type ?? null, mappedTo: target ? target.name : null });
+        }
         if (dryRun) {
             return (0, shared_js_1.ok)({
                 dryRun: true,
                 scenario: { name: name ?? record.scenario?.name ?? null, nodeCount: Array.isArray(record.scenario?.nodes) ? record.scenario?.nodes.length : null },
-                connectionsSkipped: connections.map((connection) => `${connection.name ?? connection.refId} (${connection.type ?? "?"})`),
+                connections: decisions,
                 folder: targetFolder ? { id: targetFolder.item.id, name: targetFolder.item.name } : null,
             });
         }
-        const result = await ctx.api.importScenario(ws.id, { envelope: parsed, ...(name ? { name } : {}), folderId: targetFolder?.item.id ?? null, connectionMap });
+        const result = await ctx.api.importScenario(ws.id, { envelope: parsed, ...(name ? { name } : {}), folderId: targetFolder?.item.id ?? null, connectionMap, ...(groupId ? { groupId } : {}) });
         ctx.invalidate("scenarios:");
         const scenario = result.scenario;
+        const skipped = decisions.filter((decision) => !decision.mappedTo);
         return (0, shared_js_1.ok)({
             scenario: { id: scenario.id, name: scenario.name, nodeCount: scenario.nodes?.length ?? null, reviewStatus: scenario.reviewStatus ?? null },
+            connections: decisions,
             warnings: result.warnings ?? [],
-            ...(connections.length > 0 ? { note: "Connections from the export were skipped — attach the right workspace connections to the DB/Kafka/Redis nodes in the desktop app." } : {}),
+            ...(skipped.length > 0 ? { note: `Not connected: ${skipped.map((decision) => decision.export).join(", ")} — their nodes need a connectionId (patch_scenario + list_connections).` } : {}),
             ...(targetFolder ? { resolved: [(0, resolve_js_1.resolvedSummary)(folder, targetFolder)] } : {}),
         });
     }));

package/dist-cjs/tools/index.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerAllTools = exports.toolAvailability = exports.TOOL_CATALOG = void 0;
+exports.registerAllTools = exports.withStrictArguments = exports.toolAvailability = exports.TOOL_CATALOG = void 0;
+const strict_js_1 = require("../lib/strict.js");
 const collections_js_1 = require("./collections.js");
+const contracts_js_1 = require("./contracts.js");
 const diagrams_js_1 = require("./diagrams.js");
 const environments_js_1 = require("./environments.js");
 const import_js_1 = require("./import.js");
@@ -13,14 +15,31 @@ const workspaces_js_1 = require("./workspaces.js");
 var catalog_js_1 = require("./catalog.js");
 Object.defineProperty(exports, "TOOL_CATALOG", { enumerable: true, get: function () { return catalog_js_1.TOOL_CATALOG; } });
 Object.defineProperty(exports, "toolAvailability", { enumerable: true, get: function () { return catalog_js_1.toolAvailability; } });
+// Every tool's arguments are strict: the SDK would otherwise build a
+// strip-mode object from the raw shape, and a misspelled argument
+// (`workspaceId` for `workspace`, `colour` for `color`) would vanish while the
+// tool ran with its default. Runtime only — handler types still come from the
+// raw shapes at each registerTool call.
+const isRawShape = (schema) => typeof schema === "object" && schema !== null && !("_def" in schema) && !("_zod" in schema);
+const withStrictArguments = (server) => new Proxy(server, {
+    get(target, property, receiver) {
+        if (property !== "registerTool")
+            return Reflect.get(target, property, receiver);
+        const register = (name, config, callback) => target.registerTool(name, { ...config, inputSchema: isRawShape(config.inputSchema) ? (0, strict_js_1.strictObject)(config.inputSchema, "argument", name) : config.inputSchema }, callback);
+        return register;
+    },
+});
+exports.withStrictArguments = withStrictArguments;
 // Registration order = the order clients list tools in. Run tools are only
 // registered when local execution is allowed (a backend-hosted server passes
 // allowLocalRun: false and they disappear from tools/list).
-const registerAllTools = (server, ctx) => {
+const registerAllTools = (host, ctx) => {
+    const server = (0, exports.withStrictArguments)(host);
     (0, meta_js_1.registerMetaTools)(server, ctx);
     (0, workspaces_js_1.registerWorkspaceTools)(server, ctx);
     (0, collections_js_1.registerCollectionTools)(server, ctx);
     (0, requests_js_1.registerRequestTools)(server, ctx);
+    (0, contracts_js_1.registerContractTools)(server, ctx);
     (0, import_js_1.registerImportTools)(server, ctx);
     (0, environments_js_1.registerEnvironmentTools)(server, ctx);
     (0, scenarios_js_1.registerScenarioTools)(server, ctx);