callman-mcp 0.1.1 → 0.2.0

package/dist-cjs/resources/index.js

@@ -86,22 +86,19 @@ const registerResources = (server, ctx) => {
         const { items } = await ctx.api.listEnvironments(ws.id);
         return json(uri, { workspace: { id: ws.id, name: ws.name }, environments: items.map((environment) => ({ id: environment.id, name: environment.name, variableKeys: environment.variables.map((entry) => entry.key) })) });
     });
-    server.registerResource("collection-tree", new mcp_js_1.ResourceTemplate("callman://collection/{collection}/tree", { list: undefined }), { title: "A collection's folders and requests", description: "Folders and requests of a collection (id or name) in the default workspace.", mimeType: "application/json" }, async (uri, variables) => {
-        const ws = await ctx.resolveWorkspace();
-        const resolved = await (0, lookups_js_1.resolveCollection)(ctx, ws.id, variable(variables.collection));
+    server.registerResource("collection-tree", new mcp_js_1.ResourceTemplate("callman://collection/{collection}/tree", { list: undefined }), { title: "A collection's folders and requests", description: "Folders and requests of a collection (id or name) in any of your workspaces.", mimeType: "application/json" }, async (uri, variables) => {
+        const { ws, value: resolved } = await (0, lookups_js_1.findCollection)(ctx, null, variable(variables.collection));
         const tree = await (0, lookups_js_1.loadTree)(ctx, ws.id, resolved.item.id);
-        return json(uri, { collection: { id: resolved.item.id, name: resolved.item.name }, folders: tree.folders, requests: tree.requests.map(requestShape_js_1.requestSummaryView) });
+        return json(uri, { collection: { id: resolved.item.id, name: resolved.item.name }, workspace: (0, lookups_js_1.workspaceTag)(ws), folders: tree.folders, requests: tree.requests.map(requestShape_js_1.requestSummaryView) });
     });
-    server.registerResource("request", new mcp_js_1.ResourceTemplate("callman://request/{request}", { list: undefined }), { title: "A saved request", description: "One request (id or unique name) in the default workspace, secrets masked.", mimeType: "application/json" }, async (uri, variables) => {
-        const ws = await ctx.resolveWorkspace();
-        const { request } = await (0, lookups_js_1.resolveRequest)(ctx, ws.id, variable(variables.request));
-        return json(uri, { request: (0, requestShape_js_1.compactRequestView)(request, { full: true }) });
+    server.registerResource("request", new mcp_js_1.ResourceTemplate("callman://request/{request}", { list: undefined }), { title: "A saved request", description: "One request (id or unique name) in any of your workspaces, secrets masked.", mimeType: "application/json" }, async (uri, variables) => {
+        const { ws, value } = await (0, lookups_js_1.findRequest)(ctx, null, variable(variables.request));
+        return json(uri, { request: (0, requestShape_js_1.compactRequestView)(value.request, { full: true }), workspace: (0, lookups_js_1.workspaceTag)(ws) });
     });
-    server.registerResource("environment", new mcp_js_1.ResourceTemplate("callman://environment/{environment}", { list: undefined }), { title: "An environment", description: "One environment (id or name) in the default workspace, values masked by the server.", mimeType: "application/json" }, async (uri, variables) => {
-        const ws = await ctx.resolveWorkspace();
-        const resolved = await (0, lookups_js_1.resolveEnvironment)(ctx, ws.id, variable(variables.environment));
+    server.registerResource("environment", new mcp_js_1.ResourceTemplate("callman://environment/{environment}", { list: undefined }), { title: "An environment", description: "One environment (id or name) in any of your workspaces, values masked by the server.", mimeType: "application/json" }, async (uri, variables) => {
+        const { ws, value: resolved } = await (0, lookups_js_1.findEnvironment)(ctx, null, variable(variables.environment));
         const fresh = await ctx.api.getEnvironment(ws.id, resolved.item.id);
-        return json(uri, { environment: { id: fresh.id, name: fresh.name, variables: fresh.variables } });
+        return json(uri, { environment: { id: fresh.id, name: fresh.name, variables: fresh.variables }, workspace: (0, lookups_js_1.workspaceTag)(ws) });
     });
     server.registerResource("scenario", new mcp_js_1.ResourceTemplate("callman://scenario/{scenario}", { list: undefined }), { title: "A scenario", description: "One scenario (id or name): nodes with configs (clipped, secrets masked) and edges.", mimeType: "application/json" }, async (uri, variables) => {
         const ws = await ctx.resolveWorkspaceOrNull();

package/dist-cjs/server.js

@@ -8,7 +8,7 @@ const index_js_2 = require("./resources/index.js");
 const index_js_3 = require("./tools/index.js");
 exports.SERVER_NAME = "callman";
 exports.SERVER_INSTRUCTIONS = `Callman is an API client and test platform: collections of HTTP requests, environments with variables, multi-step test scenarios, and system-design diagrams. You act as the user whose token is configured, within that token's permissions and the user's workspace role.
-Start with whoami. Names work as references (collection, folder, request, environment, scenario, diagram, workspace); ambiguous names return candidates. List before creating — duplicate collection names are refused. Preview large writes with dryRun: true; deletions need confirm: true and the user's agreement. Environment values are masked unless the token holds environments:reveal and you pass reveal: true; never write a masked value back. Arguments are strict — an unknown key is an error listing the valid ones. Read callman://docs/overview for the conventions, callman://docs/request-schema before creating or editing requests, callman://docs/contracts before contract checks, callman://docs/scenario-nodes before scenarios, and callman://docs/diagram-schema + callman://diagram/components before diagrams.`;
+Start with whoami. The token works in every workspace the user belongs to: lists and searches cover all of them unless you pass \`workspace\`, names are looked up in the default workspace first and then everywhere, and results say which workspace they come from; creating something needs a target (\`workspace\`, the collection it goes into, or the session default — use_workspace). Names work as references (collection, folder, request, environment, scenario, diagram, workspace); ambiguous names return candidates. List before creating — duplicate collection names are refused. Preview large writes with dryRun: true; deletions need confirm: true and the user's agreement. Environment values are masked unless the token holds environments:reveal and you pass reveal: true; never write a masked value back. Arguments are strict — an unknown key is an error listing the valid ones. Read callman://docs/overview for the conventions, callman://docs/request-schema before creating or editing requests, callman://docs/contracts before contract checks, callman://docs/scenario-nodes before scenarios, and callman://docs/diagram-schema + callman://diagram/components before diagrams.`;
 const createCallmanMcpServer = (options) => {
     const version = options.version ?? "0.0.0";
     const context = (0, context_js_1.createToolContext)({

package/dist-cjs/tools/catalog.js

@@ -8,6 +8,7 @@ exports.toolAvailability = exports.TOOL_CATALOG = void 0;
 exports.TOOL_CATALOG = [
     { name: "whoami", group: "meta", scopes: [] },
     { name: "list_workspaces", group: "workspaces", scopes: ["workspaces:read"] },
+    { name: "use_workspace", group: "workspaces", scopes: ["workspaces:read"] },
     { name: "list_workspace_members", group: "workspaces", scopes: ["workspaces:read"] },
     { name: "add_workspace_member", group: "workspaces", scopes: ["members:manage"] },
     { name: "update_workspace_member", group: "workspaces", scopes: ["members:manage"] },

package/dist-cjs/tools/collections.js

@@ -20,20 +20,22 @@ const runnerSettingsArg = (0, strict_js_1.strictObject)({
 const registerCollectionTools = (server, ctx) => {
     server.registerTool("list_collections", {
         title: "List collections",
-        description: "List the collections in a workspace with request/folder counts. Optional `query` filters by name (substring). Use get_collection_tree to see what is inside one.",
+        description: "List collections with request/folder counts — across ALL your workspaces unless `workspace` narrows it (the default workspace comes first; every row says its workspace). Optional `query` filters by name (substring). Use get_collection_tree to see what is inside one.",
         inputSchema: { workspace: shared_js_1.workspaceArg, query: zod_1.z.string().max(200).optional(), ...shared_js_1.cursorArgs },
         annotations: shared_js_1.READ,
     }, (0, shared_js_1.guarded)(async ({ workspace, query, cursor, limit }) => {
-        const ws = await ctx.resolveWorkspace(workspace);
-        const all = await (0, lookups_js_1.loadCollections)(ctx, ws.id);
+        const workspaces = await (0, lookups_js_1.workspacesForListing)(ctx, workspace);
         const needle = query?.trim().toLowerCase();
-        const filtered = needle ? all.filter((collection) => collection.name.toLowerCase().includes(needle)) : all;
-        const page = (0, pagination_js_1.sliceWithCursor)(filtered, cursor, limit, needle ?? "");
+        const rows = (await Promise.all(workspaces.map(async (ws) => (await (0, lookups_js_1.loadCollections)(ctx, ws.id)).map((collection) => ({ ws, collection })))))
+            .flat()
+            .filter(({ collection }) => !needle || collection.name.toLowerCase().includes(needle));
+        const page = (0, pagination_js_1.sliceWithCursor)(rows, cursor, limit, `${workspaces.map((ws) => ws.id).join(",")}|${needle ?? ""}`);
         return (0, shared_js_1.ok)({
-            workspace: { id: ws.id, name: ws.name },
-            collections: page.items.map((collection) => ({
+            ...(workspaces.length === 1 ? { workspace: (0, lookups_js_1.workspaceTag)(workspaces[0]) } : { workspaces: workspaces.map(lookups_js_1.workspaceTag) }),
+            collections: page.items.map(({ ws, collection }) => ({
                 id: collection.id,
                 name: collection.name,
+                ...(workspaces.length > 1 ? { workspace: (0, lookups_js_1.workspaceTag)(ws) } : {}),
                 requestCount: collection.requestCount ?? null,
                 folderCount: collection.folderCount ?? null,
                 updatedAt: collection.updatedAt ?? null,
@@ -44,17 +46,17 @@ const registerCollectionTools = (server, ctx) => {
     }));
     server.registerTool("get_collection_tree", {
         title: "Get a collection's folders and requests",
-        description: "The folders (with paths like \"Auth/Login\") and requests (id, name, method, url, folder) of one collection — the map you need before creating, moving or running requests.",
+        description: "The folders (with paths like \"Auth/Login\") and requests (id, name, method, url, folder) of one collection, in whichever workspace it lives — the map you need before creating, moving or running requests.",
         inputSchema: { workspace: shared_js_1.workspaceArg, collection: (0, shared_js_1.refArg)("Collection") },
         annotations: shared_js_1.READ,
     }, (0, shared_js_1.guarded)(async ({ workspace, collection }) => {
-        const ws = await ctx.resolveWorkspace(workspace);
-        const resolved = await (0, lookups_js_1.resolveCollection)(ctx, ws.id, collection);
+        const { ws, value: resolved, note } = await (0, lookups_js_1.findCollection)(ctx, workspace, collection);
         const tree = await (0, lookups_js_1.loadTree)(ctx, ws.id, resolved.item.id);
         const truncated = tree.requests.length > truncate_js_1.LIMITS.TREE_ITEMS;
         return (0, shared_js_1.ok)({
             collection: { id: resolved.item.id, name: resolved.item.name },
-            resolved: [(0, resolve_js_1.resolvedSummary)(collection, resolved)],
+            workspace: (0, lookups_js_1.workspaceTag)(ws),
+            resolved: [(0, resolve_js_1.resolvedSummary)(collection, resolved), ...(note ? [{ input: collection, note }] : [])],
             folders: tree.folders.map((folder) => ({ id: folder.id, name: folder.name, parentId: folder.parentId, path: folder.path })),
             requests: tree.requests.slice(0, truncate_js_1.LIMITS.TREE_ITEMS).map(requestShape_js_1.requestSummaryView),
             ...(truncated ? { truncated: true, totalRequests: tree.requests.length } : {}),
@@ -66,18 +68,17 @@ const registerCollectionTools = (server, ctx) => {
         inputSchema: { workspace: shared_js_1.workspaceArg, collection: (0, shared_js_1.refArg)("Collection"), format: zod_1.z.enum(["internal", "postman"]).default("internal") },
         annotations: shared_js_1.READ,
     }, (0, shared_js_1.guarded)(async ({ workspace, collection, format }) => {
-        const ws = await ctx.resolveWorkspace(workspace);
-        const resolved = await (0, lookups_js_1.resolveCollection)(ctx, ws.id, collection);
+        const { ws, value: resolved } = await (0, lookups_js_1.findCollection)(ctx, workspace, collection);
         const document = await ctx.api.exportCollection(ws.id, resolved.item.id, format);
         const bytes = (0, truncate_js_1.byteLength)(document);
         if (bytes > EXPORT_MAX_BYTES) {
             throw new errors_js_1.ToolInputError("EXPORT_TOO_LARGE", `The export is ${bytes} bytes (limit ${EXPORT_MAX_BYTES}). Export it from the desktop app instead.`, { bytes });
         }
-        return (0, shared_js_1.ok)({ collection: { id: resolved.item.id, name: resolved.item.name }, format, bytes, document: document });
+        return (0, shared_js_1.ok)({ collection: { id: resolved.item.id, name: resolved.item.name }, workspace: (0, lookups_js_1.workspaceTag)(ws), format, bytes, document: document });
     }));
     server.registerTool("create_collection", {
         title: "Create a collection",
-        description: "Create an empty collection. Refuses a name that already exists in the workspace unless allowDuplicateName is true — list_collections first and reuse an existing one when it fits.",
+        description: "Create an empty collection in `workspace` (or the session default — use_workspace; with one workspace, that one). Refuses a name that already exists in that workspace unless allowDuplicateName is true — list_collections first and reuse an existing one when it fits.",
         inputSchema: {
             workspace: shared_js_1.workspaceArg,
             name: zod_1.z.string().min(1).max(truncate_js_1.LIMITS.NAME),
@@ -95,7 +96,7 @@ const registerCollectionTools = (server, ctx) => {
         }
         const created = await ctx.api.createCollection(ws.id, { name: name.trim(), ...(runnerSettings ? { runnerSettings: compactSettings(runnerSettings) } : {}) });
         ctx.invalidate(`collections:${ws.id}`);
-        return (0, shared_js_1.ok)({ collection: { id: created.id, name: created.name }, note: "Created. Add requests with create_request / create_requests_bulk / import_content." });
+        return (0, shared_js_1.ok)({ collection: { id: created.id, name: created.name }, workspace: (0, lookups_js_1.workspaceTag)(ws), note: "Created. Add requests with create_request / create_requests_bulk / import_content." });
     }));
     server.registerTool("update_collection", {
         title: "Rename a collection / change runner settings",
@@ -110,14 +111,13 @@ const registerCollectionTools = (server, ctx) => {
     }, (0, shared_js_1.guarded)(async ({ workspace, collection, name, runnerSettings }) => {
         if (name === undefined && runnerSettings === undefined)
             throw new errors_js_1.ToolInputError("NOTHING_TO_UPDATE", "Pass name and/or runnerSettings.");
-        const ws = await ctx.resolveWorkspace(workspace);
-        const resolved = await (0, lookups_js_1.resolveCollection)(ctx, ws.id, collection);
+        const { ws, value: resolved, note } = await (0, lookups_js_1.findCollection)(ctx, workspace, collection);
         const updated = await ctx.api.updateCollection(ws.id, resolved.item.id, {
             ...(name !== undefined ? { name: name.trim() } : {}),
             ...(runnerSettings ? { runnerSettings: compactSettings(runnerSettings) } : {}),
         });
         ctx.invalidate(`collections:${ws.id}`);
-        return (0, shared_js_1.ok)({ collection: { id: updated.id, name: updated.name, runnerSettings: updated.runnerSettings ?? null }, resolved: [(0, resolve_js_1.resolvedSummary)(collection, resolved)] });
+        return (0, shared_js_1.ok)({ collection: { id: updated.id, name: updated.name, runnerSettings: updated.runnerSettings ?? null }, workspace: (0, lookups_js_1.workspaceTag)(ws), resolved: [(0, resolve_js_1.resolvedSummary)(collection, resolved), ...(note ? [{ input: collection, note }] : [])] });
     }));
     server.registerTool("create_folder", {
         title: "Create a folder",
@@ -130,8 +130,7 @@ const registerCollectionTools = (server, ctx) => {
         },
         annotations: shared_js_1.WRITE,
     }, (0, shared_js_1.guarded)(async ({ workspace, collection, name, parent }) => {
-        const ws = await ctx.resolveWorkspace(workspace);
-        const resolved = await (0, lookups_js_1.resolveCollection)(ctx, ws.id, collection);
+        const { ws, value: resolved } = await (0, lookups_js_1.findCollection)(ctx, workspace, collection);
         const parentFolder = await (0, lookups_js_1.resolveFolder)(ctx, ws.id, resolved.item.id, parent);
         const tree = await (0, lookups_js_1.loadTree)(ctx, ws.id, resolved.item.id);
         const sibling = tree.folders.find((folder) => folder.parentId === (parentFolder?.item.id ?? null) && (0, lookups_js_1.sameName)(folder.name, name));
@@ -143,6 +142,7 @@ const registerCollectionTools = (server, ctx) => {
         ctx.invalidate(`collections:${ws.id}`);
         return (0, shared_js_1.ok)({
             folder: { id: folder.id, name: folder.name, parentId: folder.parentId, path: parentFolder ? `${parentFolder.item.path}/${folder.name}` : folder.name },
+            workspace: (0, lookups_js_1.workspaceTag)(ws),
             resolved: [(0, resolve_js_1.resolvedSummary)(collection, resolved), ...(parentFolder ? [(0, resolve_js_1.resolvedSummary)(parent, parentFolder)] : [])],
         });
     }));
@@ -161,8 +161,7 @@ const registerCollectionTools = (server, ctx) => {
     }, (0, shared_js_1.guarded)(async ({ workspace, collection, folder, name, parent, targetCollection }) => {
         if (name === undefined && parent === undefined && targetCollection === undefined)
             throw new errors_js_1.ToolInputError("NOTHING_TO_UPDATE", "Pass name, parent and/or targetCollection.");
-        const ws = await ctx.resolveWorkspace(workspace);
-        const resolved = await (0, lookups_js_1.resolveCollection)(ctx, ws.id, collection);
+        const { ws, value: resolved } = await (0, lookups_js_1.findCollection)(ctx, workspace, collection);
         const target = await (0, lookups_js_1.resolveFolder)(ctx, ws.id, resolved.item.id, folder);
         if (!target)
             throw new errors_js_1.ToolInputError("REF_REQUIRED", "folder is required.");
@@ -190,12 +189,11 @@ const registerCollectionTools = (server, ctx) => {
         annotations: shared_js_1.DESTRUCTIVE,
     }, (0, shared_js_1.guarded)(async ({ workspace, collection, confirm }) => {
         (0, shared_js_1.requireConfirm)(confirm, "a collection");
-        const ws = await ctx.resolveWorkspace(workspace);
-        const resolved = await (0, lookups_js_1.resolveCollection)(ctx, ws.id, collection, { exact: true });
+        const { ws, value: resolved } = await (0, lookups_js_1.findCollection)(ctx, workspace, collection, { exact: true });
         await ctx.api.deleteCollection(ws.id, resolved.item.id);
         ctx.invalidate(`collections:${ws.id}`);
         ctx.invalidate(`tree:${ws.id}:${resolved.item.id}`);
-        return (0, shared_js_1.ok)({ deleted: { id: resolved.item.id, name: resolved.item.name }, resolved: [(0, resolve_js_1.resolvedSummary)(collection, 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)(collection, resolved)] });
     }));
     server.registerTool("delete_folder", {
         title: "Delete a folder",
@@ -204,15 +202,14 @@ const registerCollectionTools = (server, ctx) => {
         annotations: shared_js_1.DESTRUCTIVE,
     }, (0, shared_js_1.guarded)(async ({ workspace, collection, folder, confirm }) => {
         (0, shared_js_1.requireConfirm)(confirm, "a folder");
-        const ws = await ctx.resolveWorkspace(workspace);
-        const resolved = await (0, lookups_js_1.resolveCollection)(ctx, ws.id, collection);
+        const { ws, value: resolved } = await (0, lookups_js_1.findCollection)(ctx, workspace, collection);
         const target = await (0, lookups_js_1.resolveFolder)(ctx, ws.id, resolved.item.id, folder, { exact: true });
         if (!target)
             throw new errors_js_1.ToolInputError("REF_REQUIRED", "folder is required.");
         await ctx.api.deleteFolder(ws.id, target.item.id);
         ctx.invalidate(`tree:${ws.id}:${resolved.item.id}`);
         ctx.invalidate(`collections:${ws.id}`);
-        return (0, shared_js_1.ok)({ deleted: { id: target.item.id, name: target.item.name, path: target.item.path }, resolved: [(0, resolve_js_1.resolvedSummary)(collection, resolved), (0, resolve_js_1.resolvedSummary)(folder, target)] });
+        return (0, shared_js_1.ok)({ deleted: { id: target.item.id, name: target.item.name, path: target.item.path }, workspace: (0, lookups_js_1.workspaceTag)(ws), resolved: [(0, resolve_js_1.resolvedSummary)(collection, resolved), (0, resolve_js_1.resolvedSummary)(folder, target)] });
     }));
 };
 exports.registerCollectionTools = registerCollectionTools;

package/dist-cjs/tools/contracts.js

@@ -24,14 +24,15 @@ const registerContractTools = (server, ctx) => {
         inputSchema: requestArgs,
         annotations: shared_js_1.READ,
     }, (0, shared_js_1.guarded)(async ({ workspace, request, collection }) => {
-        const ws = await ctx.resolveWorkspace(workspace);
-        const { request: found, annotation } = await (0, lookups_js_1.resolveRequest)(ctx, ws.id, request, collection);
+        const { ws, value, note } = await (0, lookups_js_1.findRequest)(ctx, workspace, request, collection);
+        const { request: found, annotation } = value;
         const [rules, dataContract] = await Promise.all([ctx.api.listContractRules(ws.id, found.id), ctx.api.getDataContract(ws.id, found.id)]);
         return (0, shared_js_1.ok)({
             request: (0, requestShape_js_1.requestSummaryView)(found),
+            workspace: (0, lookups_js_1.workspaceTag)(ws),
             rules: rules.items.map(ruleView),
             dataContract: dataContract.rows.length > 0 || dataContract.columns.length > 0 ? { columns: dataContract.columns, rows: dataContract.rows } : null,
-            ...(annotation ? { resolved: [{ input: request, matched: found.name, id: found.id, note: annotation }] } : {}),
+            ...(annotation || note ? { resolved: [{ input: request, matched: found.name, id: found.id, note: [annotation, note].filter(Boolean).join("; ") }] } : {}),
         });
     }));
     server.registerTool("add_contract_rules", {
@@ -45,13 +46,14 @@ const registerContractTools = (server, ctx) => {
         },
         annotations: shared_js_1.WRITE,
     }, (0, shared_js_1.guarded)(async ({ workspace, request, collection, rules, replace, dryRun }) => {
-        const ws = await ctx.resolveWorkspace(workspace);
-        const { request: found } = await (0, lookups_js_1.resolveRequest)(ctx, ws.id, request, collection);
+        const { ws, value } = await (0, lookups_js_1.findRequest)(ctx, workspace, request, collection);
+        const { request: found } = value;
         const existing = (await ctx.api.listContractRules(ws.id, found.id)).items;
         const duplicates = replace ? [] : rules.filter((rule) => existing.some((entry) => entry.path === rule.path)).map((rule) => rule.path);
         const warnings = duplicates.length > 0 ? [`These paths already had rules and now have another one each: ${duplicates.join(", ")} — use update_contract_rule to change an existing rule instead.`] : [];
         if (dryRun) {
-            return (0, shared_js_1.ok)({ dryRun: true, request: (0, requestShape_js_1.requestSummaryView)(found), adding: rules.length, ...(replace ? { removing: existing.length } : {}), warnings });
+            return (0, shared_js_1.ok)({ dryRun: true, request: (0, requestShape_js_1.requestSummaryView)(found),
+                workspace: (0, lookups_js_1.workspaceTag)(ws), adding: rules.length, ...(replace ? { removing: existing.length } : {}), warnings });
         }
         if (replace) {
             for (const rule of existing)
@@ -60,6 +62,7 @@ const registerContractTools = (server, ctx) => {
         const created = await ctx.api.createContractRules(ws.id, { requestId: found.id, rules: rules.map((rule) => ({ ...rule, enabled: rule.enabled ?? true })) });
         return (0, shared_js_1.ok)({
             request: (0, requestShape_js_1.requestSummaryView)(found),
+            workspace: (0, lookups_js_1.workspaceTag)(ws),
             added: created.items.map(ruleView),
             ...(replace ? { removed: existing.length } : {}),
             ...(warnings.length > 0 ? { warnings } : {}),
@@ -79,9 +82,10 @@ const registerContractTools = (server, ctx) => {
     }, (0, shared_js_1.guarded)(async ({ workspace, rule, path, rules, enabled }) => {
         if (path === undefined && rules === undefined && enabled === undefined)
             throw new errors_js_1.ToolInputError("NOTHING_TO_UPDATE", "Pass path, rules and/or enabled.");
-        const ws = await ctx.resolveWorkspace(workspace);
-        const updated = await ctx.api.updateContractRule(ws.id, rule, { ...(path !== undefined ? { path } : {}), ...(rules !== undefined ? { rules } : {}), ...(enabled !== undefined ? { enabled } : {}) });
-        return (0, shared_js_1.ok)({ rule: ruleView(updated) });
+        const body = { ...(path !== undefined ? { path } : {}), ...(rules !== undefined ? { rules } : {}), ...(enabled !== undefined ? { enabled } : {}) };
+        // A rule id lives in exactly one workspace; the others answer 404.
+        const { ws, value: updated } = await (0, lookups_js_1.findInWorkspaces)(ctx, workspace, "contract rule", rule, (candidate) => ctx.api.updateContractRule(candidate.id, rule, body), { matchOf: () => "id" });
+        return (0, shared_js_1.ok)({ rule: ruleView(updated), workspace: (0, lookups_js_1.workspaceTag)(ws) });
     }));
     server.registerTool("delete_contract_rules", {
         title: "Delete contract rules",
@@ -94,8 +98,8 @@ const registerContractTools = (server, ctx) => {
         annotations: shared_js_1.DESTRUCTIVE,
     }, (0, shared_js_1.guarded)(async ({ workspace, request, collection, rules, confirm }) => {
         (0, shared_js_1.requireConfirm)(confirm, "contract rules");
-        const ws = await ctx.resolveWorkspace(workspace);
-        const { request: found } = await (0, lookups_js_1.resolveRequest)(ctx, ws.id, request, collection, { exact: true });
+        const { ws, value } = await (0, lookups_js_1.findRequest)(ctx, workspace, request, collection, { exact: true });
+        const { request: found } = value;
         const existing = (await ctx.api.listContractRules(ws.id, found.id)).items;
         const ids = rules ?? existing.map((rule) => rule.id);
         const unknown = ids.filter((id) => !existing.some((rule) => rule.id === id));
@@ -113,7 +117,8 @@ const registerContractTools = (server, ctx) => {
                 failed.push({ rule: id, error: (0, shared_js_1.failureOf)(error) });
             }
         }
-        return (0, shared_js_1.ok)({ request: (0, requestShape_js_1.requestSummaryView)(found), deleted, failed });
+        return (0, shared_js_1.ok)({ request: (0, requestShape_js_1.requestSummaryView)(found),
+            workspace: (0, lookups_js_1.workspaceTag)(ws), deleted, failed });
     }));
     server.registerTool("test_contract_rules", {
         title: "Test contract rules against a response body",
@@ -124,10 +129,11 @@ const registerContractTools = (server, ctx) => {
         },
         annotations: shared_js_1.READ,
     }, (0, shared_js_1.guarded)(async ({ workspace, request, collection, responseBody }) => {
-        const ws = await ctx.resolveWorkspace(workspace);
-        const { request: found } = await (0, lookups_js_1.resolveRequest)(ctx, ws.id, request, collection);
+        const { ws, value } = await (0, lookups_js_1.findRequest)(ctx, workspace, request, collection);
+        const { request: found } = value;
         const result = await ctx.api.validateContractRules(ws.id, { requestId: found.id, responseBody: responseBody ?? null });
-        return (0, shared_js_1.ok)({ request: (0, requestShape_js_1.requestSummaryView)(found), summary: result.summary, results: result.results });
+        return (0, shared_js_1.ok)({ request: (0, requestShape_js_1.requestSummaryView)(found),
+            workspace: (0, lookups_js_1.workspaceTag)(ws), summary: result.summary, results: result.results });
     }));
     server.registerTool("set_data_contract", {
         title: "Set a request's data-driven contract",
@@ -143,13 +149,14 @@ const registerContractTools = (server, ctx) => {
         if (undeclared.length > 0) {
             throw new errors_js_1.ToolInputError("DATA_COLUMN_UNDECLARED", `Rows use column(s) not in columns: ${undeclared.join(", ")}.`);
         }
-        const ws = await ctx.resolveWorkspace(workspace);
-        const { request: found } = await (0, lookups_js_1.resolveRequest)(ctx, ws.id, request, collection);
+        const { ws, value } = await (0, lookups_js_1.findRequest)(ctx, workspace, request, collection);
+        const { request: found } = value;
         const saved = await ctx.api.putDataContract(ws.id, { requestId: found.id, columns, rows });
         const text = JSON.stringify([found.url, found.headers, found.body, found.query]);
         const unused = columns.filter((column) => !text.includes(`{{data.${column}}}`));
         return (0, shared_js_1.ok)({
             request: (0, requestShape_js_1.requestSummaryView)(found),
+            workspace: (0, lookups_js_1.workspaceTag)(ws),
             dataContract: { columns: saved.columns, rows: saved.rows.length },
             ...(unused.length > 0 ? { warnings: [`The request does not reference {{data.${unused.join("}}, {{data.")}}} yet — add them to its url, query, headers or body with update_request.`] } : {}),
         });
@@ -161,27 +168,29 @@ const registerContractTools = (server, ctx) => {
         annotations: shared_js_1.DESTRUCTIVE,
     }, (0, shared_js_1.guarded)(async ({ workspace, request, collection, confirm }) => {
         (0, shared_js_1.requireConfirm)(confirm, "a data contract");
-        const ws = await ctx.resolveWorkspace(workspace);
-        const { request: found } = await (0, lookups_js_1.resolveRequest)(ctx, ws.id, request, collection, { exact: true });
+        const { ws, value } = await (0, lookups_js_1.findRequest)(ctx, workspace, request, collection, { exact: true });
+        const { request: found } = value;
         await ctx.api.deleteDataContract(ws.id, found.id);
-        return (0, shared_js_1.ok)({ request: (0, requestShape_js_1.requestSummaryView)(found), deleted: true });
+        return (0, shared_js_1.ok)({ request: (0, requestShape_js_1.requestSummaryView)(found),
+            workspace: (0, lookups_js_1.workspaceTag)(ws), deleted: true });
     }));
     server.registerTool("list_connections", {
         title: "List workspace connections",
-        description: "List the workspace's database / Redis / Kafka / notification / AI connections (id, name, type, provider — never credentials). Request database/Kafka/Redis steps and scenario db/redis/kafka/notification/ai nodes reference a connection by this id (or name). Connections are created and tested in the desktop app.",
+        description: "List database / Redis / Kafka / notification / AI connections (id, name, type, provider, workspace — never credentials) across all your workspaces, or one `workspace`. A connection belongs to one workspace: use one from the same workspace as the request or scenario. Request database/Kafka/Redis steps and scenario db/redis/kafka/notification/ai nodes reference a connection by this id (or name). Connections are created and tested in the desktop app.",
         inputSchema: {
             workspace: shared_js_1.workspaceArg,
             type: zod_1.z.enum(["database", "redis", "kafka", "notification", "ai"]).optional(),
         },
         annotations: shared_js_1.READ,
     }, (0, shared_js_1.guarded)(async ({ workspace, type }) => {
-        const ws = await ctx.resolveWorkspace(workspace);
-        const connections = await ctx.api.listConnections(ws.id, type);
+        const workspaces = await (0, lookups_js_1.workspacesForListing)(ctx, workspace);
+        const perWorkspace = await Promise.all(workspaces.map(async (ws) => (await ctx.api.listConnections(ws.id, type)).map((connection) => ({ ws, connection }))));
         return (0, shared_js_1.ok)({
-            workspace: { id: ws.id, name: ws.name },
-            connections: connections.map((connection) => ({
+            ...(workspaces.length === 1 ? { workspace: (0, lookups_js_1.workspaceTag)(workspaces[0]) } : { workspaces: workspaces.map(lookups_js_1.workspaceTag) }),
+            connections: perWorkspace.flat().map(({ ws, connection }) => ({
                 id: connection.id,
                 name: connection.name,
+                ...(workspaces.length > 1 ? { workspace: (0, lookups_js_1.workspaceTag)(ws) } : {}),
                 type: connection.type,
                 provider: connection.provider,
                 ...(connection.description ? { description: connection.description } : {}),

package/dist-cjs/tools/environments.js

@@ -47,24 +47,28 @@ const loadGlobals = async (ctx, ws, reveal) => {
 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), loadGlobals(ctx, ws.id, false)]);
-        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),
-                ...(environment.variables.length > 200 ? { variableKeysTruncated: true } : {}),
-            })),
-            globalVariableKeys: globals.globals.map((variable) => variable.key),
-            ...(globals.globalVariablesError ? { globalVariablesError: globals.globalVariablesError } : {}),
-        });
+        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",
@@ -72,22 +76,22 @@ const registerEnvironmentTools = (server, ctx) => {
         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 { 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 })) },
+            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 variables ({ key, value }, up to ${VARIABLES_MAX}). Use it for hosts ({{baseUrl}}) and credentials so requests never hard-code them. Names must be unique in the workspace.`,
+        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().trim().min(1).max(truncate_js_1.LIMITS.NAME),
@@ -107,7 +111,7 @@ const registerEnvironmentTools = (server, ctx) => {
         }
         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",
@@ -115,14 +119,13 @@ const registerEnvironmentTools = (server, ctx) => {
         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 = 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);
         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 }, resolved: [(0, resolve_js_1.resolvedSummary)(environment, resolved)] });
+        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 / rename / unset environment variables",
@@ -145,8 +148,7 @@ const registerEnvironmentTools = (server, ctx) => {
         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 = 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);
         const existingKeys = new Set(resolved.item.variables.map((variable) => variable.key));
         const updated = [];
         const added = [];
@@ -200,7 +202,7 @@ const registerEnvironmentTools = (server, ctx) => {
         }
         ctx.invalidate(`environments:${ws.id}`);
         const changed = updated.length + added.length + renamed.length + removed.length;
-        const body = { environment: { id: resolved.item.id, name: resolved.item.name }, updated, added, renamed, removed, notFound, failed, resolved: [(0, resolve_js_1.resolvedSummary)(environment, resolved)] };
+        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)) };
         }
@@ -208,7 +210,7 @@ const registerEnvironmentTools = (server, ctx) => {
     }));
     server.registerTool("set_global_variables", {
         title: "Set / unset global variables",
-        description: "Upsert (`set`: { key, value }) and/or remove (`unset`, needs environments:delete) workspace GLOBAL variables — shared by every environment and resolved as {{key}} when no environment defines it, or explicitly as {{global.key}}. A masked value (••••…) is refused.",
+        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(),
@@ -262,11 +264,10 @@ const registerEnvironmentTools = (server, ctx) => {
         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, { exact: true });
+        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

@@ -29,7 +29,10 @@ const registerImportTools = (server, ctx) => {
         },
         annotations: shared_js_1.WRITE,
     }, (0, shared_js_1.guarded)(async ({ workspace, content, fileName, format, collectionName, targetCollection, folder, environment, dryRun }) => {
-        const ws = await ctx.resolveWorkspace(workspace);
+        // 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;
@@ -76,7 +79,7 @@ const registerImportTools = (server, ctx) => {
                 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 });
@@ -94,7 +97,7 @@ const registerImportTools = (server, ctx) => {
                 }
                 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, ...(await applyFileVariables()), 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) {
@@ -107,7 +110,7 @@ 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, ...(await applyFileVariables()) });
+            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}".`);
@@ -131,6 +134,7 @@ const registerImportTools = (server, ctx) => {
         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) } } : {}),