mc8yp 2.3.1 → 2.3.3

package/dist/cli.mjs

@@ -1545,7 +1545,7 @@ const consola = createConsola();
 //#endregion
 //#region package.json
 var name = "mc8yp";
-var version = "2.3.1";
+var version = "2.3.3";
 var description$1 = "Cumulocity IoT MCP Server - Model Context Protocol integration for IoT device management";
 //#endregion
 //#region \0virtual:core-openapi
@@ -165490,6 +165490,18 @@ var Client = class Client {
 * Shared client authentication utility.
 * Centralizes the logic for getting an authenticated C8y client.
 */
+/**
+* Map a \@c8y/client error (which is thrown as `{ res, data }` for HTTP
+* statuses >= 400) to a short human-readable string.
+* @param err - Error thrown by an \@c8y/client service call
+*/
+function c8yErrorSummary(err) {
+	if (err && typeof err === "object" && "res" in err) {
+		const r = err.res;
+		if (r && typeof r.status === "number") return `${r.status} ${r.statusText ?? ""}`.trim();
+	}
+	return err instanceof Error ? err.message : String(err);
+}
 async function resolveC8yAuth() {
 	const custom = c8yMcpServer.ctx.custom;
 	const auth = custom?.auth;
@@ -165898,7 +165910,9 @@ function normalizeCode(functionCode) {
 }
 function buildQueryScript(sourceCode) {
 	const functionExpression = normalizeCode(sourceCode);
-	const resolved = c8yMcpServer.ctx.custom?.specs;
+	const custom = c8yMcpServer.ctx.custom;
+	const resolved = custom?.specs;
+	if (!resolved) throw new Error(custom?.env === "cli" ? "No active tenant set. Call set-active-tenant first." : "No tenant specs available for this MCP connection. This usually means the request reached the server without a resolvable tenant context (e.g. a platform probe). Reconnect with valid tenant auth.");
 	return [
 		`const coreSpec = ${JSON.stringify(resolved.core)};`,
 		`const serviceSpecs = ${JSON.stringify(resolved.specs)};`,
@@ -165969,6 +165983,7 @@ async function query(functionCode) {
 	if (!result.ok) throw new Error(`Execution failed with code ${result.error.code}: ${result.error.message}`);
 	const value = extractDefaultExport(result.exports);
 	const body = typeof value === "string" ? value : JSON.stringify(value);
+	if (c8yMcpServer.ctx.custom?.env !== "cli") return body;
 	const tenantUrl = c8yMcpServer.ctx.custom?.auth?.tenantUrl;
 	return `${body}\n\n---\n${tenantUrl ? `Query ran against tenant: ${tenantUrl}. Visible specs are everything currently available for that tenant.` : "Query ran against bundled OpenAPI snapshots only — no active tenant. Visibility here does NOT guarantee any service is installed on a tenant."}`;
 }
@@ -166007,23 +166022,22 @@ function getOpenApiNote() {
 	return "This MCP exposes a bundled Cumulocity core OpenAPI snapshot. Use `coreSpec` for inventory, alarms, events, measurements, users, tenants, and the broader Cumulocity REST surface. Bundled and discovered microservice APIs available on the current tenant are exposed via `serviceSpecs` (keyed by contextPath).";
 }
 function getQuerySafetyPreface(env) {
-	const sharedFooter = "Every result ends with a footer line naming the active tenant (or noting there is none) so you can verify which tenant the result reflects before acting on it.";
-	if (env !== "cli") return sharedFooter;
-	return [
-		"**CLI mode — read first.** The active tenant is global to this CLI session and can be flipped between calls by `set-active-tenant`. Always check the footer line at the bottom of every result. If it says \"no active tenant\" you are looking at bundled reference snapshots — call `cli-status` to see stored credentials and `set-active-tenant` to connect before relying on the result.",
-		"",
-		sharedFooter
-	].join("\n");
+	if (env === "server") return "Searches the bundled and discovered OpenAPI specs available to the current connection.";
+	return "**Read first.** The active tenant is global to this CLI session and can be flipped between calls by `set-active-tenant`. Every result ends with a footer line naming the active tenant (or noting there is none) so you can verify which tenant the result reflects before acting on it. If the footer says \"no active tenant\" you are looking at bundled reference snapshots — call `cli-status` to see stored credentials and `set-active-tenant` to connect before relying on the result.";
 }
 function getExecuteSafetyPreface(env) {
 	const sharedFooter = "An endpoint visible in `query` may still return 404 from `execute` when the service is not actually installed on the current tenant.";
-	if (env !== "cli") return sharedFooter;
+	if (env === "server") return sharedFooter;
 	return [
-		"**CLI mode — read first.** Every result starts with an `Executed against tenant: <url>` marker line followed by a blank line. Verify it matches the tenant you intend to mutate before reporting the result. The active tenant is global to this CLI session and can be flipped between calls by `set-active-tenant`. If no tenant is active `execute` fails with a missing-auth error — call `cli-status` and `set-active-tenant` to connect first.",
+		"**Read first.** Every result starts with an `Executed against tenant: <url>` marker line followed by a blank line. Verify it matches the tenant you intend to mutate before reporting the result. The active tenant is global to this CLI session and can be flipped between calls by `set-active-tenant`. If no tenant is active `execute` fails with a missing-auth error — call `cli-status` and `set-active-tenant` to connect first.",
 		"",
 		sharedFooter
 	].join("\n");
 }
+function getQueryResultDescription(env) {
+	if (env === "server") return "If your function returns a string it is returned as-is. Any other value is returned as JSON.";
+	return "If your function returns a string it is returned as-is. Any other value is returned as JSON. A footer line naming the active tenant (or noting there is none) is appended after a `---` separator on every successful result.";
+}
 function createQueryTool(env) {
 	return defineTool({
 		name: "query",
@@ -166066,7 +166080,7 @@ declare const serviceSpecs: Record<string, Spec>
 - \`coreSpec\` — the main Cumulocity REST surface. Always present.
 - \`serviceSpecs\` — microservice APIs available on the active tenant, keyed by contextPath. An entry is **present iff** the service is reachable on this tenant. Paths are already prefixed (e.g. \`/service/myservice/items\`). Check with \`serviceSpecs.dtm\` (or \`'dtm' in serviceSpecs\`) before reaching in.
 
-If your function returns a string it is returned as-is. Any other value is returned as JSON. A footer line naming the active tenant (or noting there is none) is appended after a \`---\` separator on every successful result.
+${getQueryResultDescription(env)}
 The current MCP connection may still block \`execute\` calls even when an operation is visible in a spec.
 
 Examples:
@@ -166153,57 +166167,28 @@ function createTools(env) {
 * description lambda in CLI mode) can read the last known result without
 * awaiting.
 */
-const specPromises = /* @__PURE__ */ new Map();
-const refreshTimers = /* @__PURE__ */ new Map();
-const DISCOVERY_REFRESH_INTERVAL_MS = 1800 * 1e3;
-function normalizeTenantUrl(url) {
-	try {
-		return new URL(url).toString().replace(/\/$/, "");
-	} catch {
-		return url.replace(/\/$/, "");
-	}
-}
-function clearRefreshTimer(key) {
-	const t = refreshTimers.get(key);
-	if (t) {
-		clearTimeout(t);
-		refreshTimers.delete(key);
-	}
-}
-function scheduleRefresh(key, authHeaders) {
-	clearRefreshTimer(key);
-	const timer = setTimeout(() => {
-		refreshTimers.delete(key);
-		const empty = {
-			specs: [],
-			installedContextPaths: /* @__PURE__ */ new Set()
-		};
-		const promise = discoverApiSpecs(key, authHeaders).catch(() => empty);
-		specPromises.set(key, promise);
-		promise.then(() => scheduleRefresh(key, authHeaders)).catch(() => {});
-	}, DISCOVERY_REFRESH_INTERVAL_MS);
-	timer.unref?.();
-	refreshTimers.set(key, timer);
-}
+const cache = /* @__PURE__ */ new Map();
 /**
 * Start discovery for the given tenant if not already started, or return the
-* existing in-flight promise. Idempotent — safe to call on every request.
-* @param tenantUrl - Base URL of the Cumulocity tenant
-* @param authHeaders - Auth headers used for all discovery requests
+* existing in-flight / last-known-good promise. Idempotent — safe to call
+* on every request.
+*
+* Failure handling: if the discovery promise rejects and there is no
+* prior cached result, the in-flight entry is removed so the next caller
+* retries, and the rejection propagates to the current caller (the request
+* fails). A prior successful entry is never overwritten by a failure.
+* @param tenantId - Cumulocity tenant ID; used as the cache key
+* @param client - Configured Cumulocity client for all API reads
 */
-function startDiscovery(tenantUrl, authHeaders) {
-	const key = normalizeTenantUrl(tenantUrl);
-	if (specPromises.has(key)) return specPromises.get(key);
-	const empty = {
-		specs: [],
-		installedContextPaths: /* @__PURE__ */ new Set()
-	};
-	const promise = discoverApiSpecs(key, authHeaders).catch((err) => {
-		consola.warn(`API spec discovery failed for ${key}:`, err instanceof Error ? err.message : String(err));
-		return empty;
+function startDiscovery(tenantId, client) {
+	const existing = cache.get(tenantId);
+	if (existing) return existing;
+	const promise = discoverApiSpecs(client, tenantId);
+	cache.set(tenantId, promise);
+	promise.catch((err) => {
+		consola.warn(`API spec discovery failed for tenant ${tenantId}:`, c8yErrorSummary(err));
+		if (cache.get(tenantId) === promise) cache.delete(tenantId);
 	});
-	promise.then(() => scheduleRefresh(key, authHeaders)).catch(() => {});
-	specPromises.set(key, promise);
 	return promise;
 }
 function rewriteDiscoveredSpecPaths(spec, servicePrefix) {
@@ -166220,23 +166205,28 @@ function rewriteDiscoveredSpecPaths(spec, servicePrefix) {
 }
 /**
 * Fetch and return discovered specs for the given tenant.
-* Throws on fatal errors; individual spec download failures are skipped.
-* @param tenantUrl - Normalised base URL of the Cumulocity tenant
-* @param authHeaders - Auth headers for all HTTP requests
+* Throws on fatal errors (applications listing); individual spec download
+* failures are skipped.
+*
+* Uses `applicationsByTenant/{tenantId}` (via `listByTenant`) rather than
+* the user-scoped `applicationsByUser` endpoint so the call works with
+* service-user credentials — service users cannot call /user/currentUser,
+* which the user-scoped endpoint depends on. The tenantId is always known
+* at the call site (it is the discovery cache key).
+*
+* All Cumulocity API calls go through the provided \@c8y/client. This module
+* never touches `fetch` directly so auth strategy choice (Basic, Bearer,
+* cookie, service-user) stays in the client construction layer.
+* @param client - Configured Cumulocity client used for all API reads
+* @param tenantId - Cumulocity tenant ID to list applications for
 */
-async function discoverApiSpecs(tenantUrl, authHeaders) {
-	const baseUrl = normalizeTenantUrl(tenantUrl);
-	const headers = {
-		...authHeaders,
-		Accept: "application/json"
-	};
-	const userRes = await fetch(`${baseUrl}/user/currentUser`, { headers });
-	if (!userRes.ok) throw new Error(`Failed to fetch current user: ${userRes.status} ${userRes.statusText}`);
-	const currentUser = await userRes.json();
-	if (!currentUser.id) throw new Error("Could not determine current user ID from /user/currentUser response");
-	const appsRes = await fetch(`${baseUrl}/application/applicationsByUser/${encodeURIComponent(currentUser.id)}?pageSize=2000`, { headers });
-	if (!appsRes.ok) throw new Error(`Failed to fetch applications: ${appsRes.status} ${appsRes.statusText}`);
-	const apps = (await appsRes.json()).applications ?? [];
+async function discoverApiSpecs(client, tenantId) {
+	let apps;
+	try {
+		apps = (await client.application.listByTenant(tenantId, { pageSize: 2e3 })).data ?? [];
+	} catch (err) {
+		throw new Error(`Failed to fetch applications: ${c8yErrorSummary(err)}`);
+	}
 	const appsWithSpec = apps.filter((app) => typeof app.contextPath === "string" && app.contextPath.length > 0 && typeof app.name === "string" && app.name.length > 0 && app.manifest != null && app.manifest.openApiSpec != null);
 	const seenContextPaths = /* @__PURE__ */ new Map();
 	for (const app of appsWithSpec) {
@@ -166256,7 +166246,7 @@ async function discoverApiSpecs(tenantUrl, authHeaders) {
 			path: app.manifest.openApiSpec
 		}] : app.manifest.openApiSpec;
 		for (const entry of entries) try {
-			const specRes = await fetch(`${baseUrl}${servicePrefix}/${entry.path.replace(/^\//, "")}`, { headers });
+			const specRes = await client.core.fetch(`${servicePrefix}/${entry.path.replace(/^\//, "")}`);
 			if (!specRes.ok) continue;
 			specs.push({
 				contextPath: app.contextPath,
@@ -174139,8 +174129,14 @@ function clearCliTenantContext() {
 * @param tenantUrl - Base URL of the Cumulocity tenant to activate
 */
 async function setCliTenantContext(tenantUrl) {
-	const authHeaders = createC8yAuthHeaders(await globalThis._getCredentialsByTenantUrl(tenantUrl));
-	const { specs: discovered, installedContextPaths } = await startDiscovery(tenantUrl, authHeaders);
+	const creds = await globalThis._getCredentialsByTenantUrl(tenantUrl);
+	const authHeaders = createC8yAuthHeaders(creds);
+	const cliClient = new Client(new BasicAuth({
+		tenant: creds.tenantId,
+		user: creds.user,
+		password: creds.password
+	}), tenantUrl);
+	const { specs: discovered, installedContextPaths } = await startDiscovery(creds.tenantId, cliClient);
 	_context = {
 		tenantUrl,
 		authorizationHeader: authHeaders.Authorization,
@@ -174408,8 +174404,10 @@ runMain(defineCommand({
 		const activeTenant = readActiveTenantUrl();
 		if (activeTenant) try {
 			const tenantCtx = await setCliTenantContext(activeTenant);
-			const specKeys = ["core", ...Object.keys(tenantCtx.specs.specs)];
-			consola.info(`Active tenant: ${activeTenant}. Available specs: ${specKeys.join(", ")}`);
+			const serviceKeys = Object.keys(tenantCtx.specs.specs);
+			consola.info(`Active tenant: ${activeTenant}`);
+			consola.info(`Startup discovery complete: ${serviceKeys.length} microservice API spec(s) found${serviceKeys.length > 0 ? ` [${serviceKeys.join(", ")}]` : ""}`);
+			consola.info(`Available specs: ${["core", ...serviceKeys].join(", ")}`);
 		} catch (err) {
 			const message = err instanceof Error ? err.message : String(err);
 			if (message.includes("No stored credentials found for tenant URL")) {
@@ -174417,7 +174415,7 @@ runMain(defineCommand({
 				consola.warn(`Active tenant ${activeTenant} was cleared because no credentials are stored for it. Call set-active-tenant with a known tenant URL or run 'creds add' first.`);
 			} else consola.warn(`Could not activate tenant ${activeTenant}:`, message);
 		}
-		else consola.info("No active tenant set. Call set-active-tenant to connect before using query or execute.");
+		else consola.info("No active tenant set. Call set-active-tenant to connect before using query or execute. Discovery will run once a tenant is activated.");
 		setupMcpServer("cli");
 		const transport = new StdioTransport(c8yMcpServer);
 		const active = getCliTenantContext();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mc8yp",
-  "version": "2.3.1",
+  "version": "2.3.3",
   "type": "module",
   "description": "Cumulocity IoT MCP Server - Model Context Protocol integration for IoT device management",
   "keywords": [