@burdenoff/mcp-libs 2026.628.1 → 2026.629.1

package/dist/modules/adaptercloud/index.cjs

@@ -0,0 +1,1841 @@
+'use strict';
+
+var zod = require('zod');
+require('graphql-request');
+require('cross-fetch');
+require('@modelcontextprotocol/sdk/server/mcp.js');
+require('@modelcontextprotocol/sdk/types.js');
+
+// src/modules/adaptercloud/tools/adapters.ts
+
+// src/core/errors.ts
+var McpInternalError = class extends Error {
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.name = "McpInternalError";
+    this.cause = cause;
+  }
+};
+
+// src/core/result.ts
+function jsonResult(data, structured) {
+  const result = {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+  return result;
+}
+function errorResult(message, hint) {
+  const text = hint ? `${message}
+
+Hint: ${hint}` : message;
+  return { content: [{ type: "text", text }], isError: true };
+}
+
+// src/core/tool-name.ts
+var MAX_TOOL_NAME_LENGTH = 63;
+function assertSafeName(name, kind) {
+  if (name.length > MAX_TOOL_NAME_LENGTH) {
+    throw new McpInternalError(
+      `Tool name '${name}' exceeds ${MAX_TOOL_NAME_LENGTH} characters (some MCP clients truncate at 64).`
+    );
+  }
+  return name;
+}
+function mcpToolName(productName, ...parts) {
+  if (!productName) {
+    throw new McpInternalError("mcpToolName: productName is required");
+  }
+  const name = [productName, ...parts].filter(Boolean).join("_");
+  return assertSafeName(name);
+}
+function mcpResourceUri(productName, ...parts) {
+  if (!productName) {
+    throw new McpInternalError("mcpResourceUri: productName is required");
+  }
+  return `${productName}://${parts.filter(Boolean).join("/")}`;
+}
+function mcpPromptName(productName, ...parts) {
+  if (!productName) {
+    throw new McpInternalError("mcpPromptName: productName is required");
+  }
+  return [productName, ...parts].filter(Boolean).join("-");
+}
+
+// src/modules/adaptercloud/operations.ts
+var PAGE_INFO_FIELDS = `
+  pageInfo { cursor hasMore }
+`;
+var ADAPTER_FIELDS = `
+  id name slug description kind status vendor version capabilities configSchema
+  tags workspaceId createdAt updatedAt
+`;
+var CONNECTION_FIELDS = `
+  id name adapterId authMethod status environment region config secretRef
+  targetRef resourceCount lastSyncedAt lastError tags workspaceId
+  createdAt updatedAt
+`;
+var RESOURCE_FIELDS = `
+  id connectionId externalId name resourceType region state monthlyCost
+  attributes providerTags tags lastSeenAt workspaceId createdAt updatedAt
+`;
+var TOPOLOGY_EDGE_FIELDS = `
+  id fromResourceId toResourceId kind weight bidirectional attributes
+  workspaceId createdAt updatedAt
+`;
+var POLICY_FIELDS = `
+  id name description kind enforcement severity expression appliesTo isActive
+  tags workspaceId createdAt updatedAt
+`;
+var VIOLATION_FIELDS = `
+  id policyId resourceId severity status message evidence detectedAt
+  resolvedAt resolvedById waiverReason workspaceId createdAt updatedAt
+`;
+var DRIFT_FIELDS = `
+  id resourceId attributePath expectedValue observedValue severity status
+  detectedAt remediatedAt workspaceId createdAt updatedAt
+`;
+var SYNC_RUN_FIELDS = `
+  id connectionId kind status startedAt finishedAt discoveredCount
+  reconciledCount driftCount violationCount summary error workspaceId
+  createdAt updatedAt
+`;
+var COST_RECORD_FIELDS = `
+  id connectionId resourceId service amount currency periodStart periodEnd
+  breakdown workspaceId createdAt updatedAt
+`;
+var GET_ADAPTER = `
+  query AdaGetAdapter($id: ID!) {
+    adaAdapter(id: $id) {
+      ${ADAPTER_FIELDS}
+      connections { id name status environment resourceCount }
+    }
+  }
+`;
+var LIST_ADAPTERS = `
+  query AdaListAdapters(
+    $kind: AdaAdapterKind
+    $status: AdaAdapterStatus
+    $pagination: PaginationInput
+  ) {
+    adaListAdapters(kind: $kind, status: $status, pagination: $pagination) {
+      items { ${ADAPTER_FIELDS} }
+      ${PAGE_INFO_FIELDS}
+    }
+  }
+`;
+var CREATE_ADAPTER = `
+  mutation AdaCreateAdapter($input: AdaCreateAdapterInput!) {
+    adaCreateAdapter(input: $input) {
+      ${ADAPTER_FIELDS}
+    }
+  }
+`;
+var UPDATE_ADAPTER = `
+  mutation AdaUpdateAdapter($id: ID!, $input: AdaUpdateAdapterInput!) {
+    adaUpdateAdapter(id: $id, input: $input) {
+      ${ADAPTER_FIELDS}
+    }
+  }
+`;
+var ARCHIVE_ADAPTER = `
+  mutation AdaArchiveAdapter($id: ID!) {
+    adaArchiveAdapter(id: $id)
+  }
+`;
+var GET_CONNECTION = `
+  query AdaGetConnection($id: ID!) {
+    adaConnection(id: $id) {
+      ${CONNECTION_FIELDS}
+      adapter { id name slug kind status }
+      resources { id name resourceType state monthlyCost }
+    }
+  }
+`;
+var LIST_CONNECTIONS = `
+  query AdaListConnections(
+    $adapterId: ID
+    $status: AdaConnectionStatus
+    $pagination: PaginationInput
+  ) {
+    adaListConnections(adapterId: $adapterId, status: $status, pagination: $pagination) {
+      items { ${CONNECTION_FIELDS} }
+      ${PAGE_INFO_FIELDS}
+    }
+  }
+`;
+var CREATE_CONNECTION = `
+  mutation AdaCreateConnection($input: AdaCreateConnectionInput!) {
+    adaCreateConnection(input: $input) {
+      ${CONNECTION_FIELDS}
+    }
+  }
+`;
+var UPDATE_CONNECTION = `
+  mutation AdaUpdateConnection($id: ID!, $input: AdaUpdateConnectionInput!) {
+    adaUpdateConnection(id: $id, input: $input) {
+      ${CONNECTION_FIELDS}
+    }
+  }
+`;
+var DISABLE_CONNECTION = `
+  mutation AdaDisableConnection($id: ID!) {
+    adaDisableConnection(id: $id) {
+      ${CONNECTION_FIELDS}
+    }
+  }
+`;
+var SET_CONNECTION_STATUS = `
+  mutation AdaSetConnectionStatus($id: ID!, $status: AdaConnectionStatus!) {
+    adaSetConnectionStatus(id: $id, status: $status) {
+      ${CONNECTION_FIELDS}
+    }
+  }
+`;
+var GET_RESOURCE = `
+  query AdaGetResource($id: ID!) {
+    adaResource(id: $id) {
+      ${RESOURCE_FIELDS}
+      connection { id name status }
+      dependsOn { id name resourceType state }
+    }
+  }
+`;
+var LIST_RESOURCES = `
+  query AdaListResources(
+    $connectionId: ID
+    $resourceType: String
+    $state: AdaResourceState
+    $pagination: PaginationInput
+  ) {
+    adaListResources(
+      connectionId: $connectionId
+      resourceType: $resourceType
+      state: $state
+      pagination: $pagination
+    ) {
+      items { ${RESOURCE_FIELDS} }
+      ${PAGE_INFO_FIELDS}
+    }
+  }
+`;
+var REGISTER_RESOURCE = `
+  mutation AdaRegisterResource($input: AdaRegisterResourceInput!) {
+    adaRegisterResource(input: $input) {
+      ${RESOURCE_FIELDS}
+    }
+  }
+`;
+var LIST_TOPOLOGY_EDGES = `
+  query AdaListTopologyEdges($kind: AdaEdgeKind, $resourceId: ID) {
+    adaListTopologyEdges(kind: $kind, resourceId: $resourceId) {
+      ${TOPOLOGY_EDGE_FIELDS}
+    }
+  }
+`;
+var CREATE_TOPOLOGY_EDGE = `
+  mutation AdaCreateTopologyEdge($input: AdaCreateTopologyEdgeInput!) {
+    adaCreateTopologyEdge(input: $input) {
+      ${TOPOLOGY_EDGE_FIELDS}
+    }
+  }
+`;
+var GET_POLICY = `
+  query AdaGetPolicy($id: ID!) {
+    adaPolicy(id: $id) {
+      ${POLICY_FIELDS}
+      violations { id resourceId severity status message }
+    }
+  }
+`;
+var LIST_POLICIES = `
+  query AdaListPolicies(
+    $kind: AdaPolicyKind
+    $isActive: Boolean
+    $pagination: PaginationInput
+  ) {
+    adaListPolicies(kind: $kind, isActive: $isActive, pagination: $pagination) {
+      items { ${POLICY_FIELDS} }
+      ${PAGE_INFO_FIELDS}
+    }
+  }
+`;
+var CREATE_POLICY = `
+  mutation AdaCreatePolicy($input: AdaCreatePolicyInput!) {
+    adaCreatePolicy(input: $input) {
+      ${POLICY_FIELDS}
+    }
+  }
+`;
+var UPDATE_POLICY = `
+  mutation AdaUpdatePolicy($id: ID!, $input: AdaUpdatePolicyInput!) {
+    adaUpdatePolicy(id: $id, input: $input) {
+      ${POLICY_FIELDS}
+    }
+  }
+`;
+var ARCHIVE_POLICY = `
+  mutation AdaArchivePolicy($id: ID!) {
+    adaArchivePolicy(id: $id)
+  }
+`;
+var LIST_VIOLATIONS = `
+  query AdaListViolations(
+    $policyId: ID
+    $resourceId: ID
+    $status: AdaViolationStatus
+    $pagination: PaginationInput
+  ) {
+    adaListViolations(
+      policyId: $policyId
+      resourceId: $resourceId
+      status: $status
+      pagination: $pagination
+    ) {
+      items { ${VIOLATION_FIELDS} }
+      ${PAGE_INFO_FIELDS}
+    }
+  }
+`;
+var RECORD_VIOLATION = `
+  mutation AdaRecordViolation($input: AdaRecordViolationInput!) {
+    adaRecordViolation(input: $input) {
+      ${VIOLATION_FIELDS}
+    }
+  }
+`;
+var RESOLVE_VIOLATION = `
+  mutation AdaResolveViolation(
+    $id: ID!
+    $status: AdaViolationStatus!
+    $waiverReason: String
+  ) {
+    adaResolveViolation(id: $id, status: $status, waiverReason: $waiverReason) {
+      ${VIOLATION_FIELDS}
+    }
+  }
+`;
+var LIST_DRIFT_RECORDS = `
+  query AdaListDriftRecords($resourceId: ID, $status: AdaDriftStatus) {
+    adaListDriftRecords(resourceId: $resourceId, status: $status) {
+      ${DRIFT_FIELDS}
+    }
+  }
+`;
+var RECORD_DRIFT = `
+  mutation AdaRecordDrift($input: AdaRecordDriftInput!) {
+    adaRecordDrift(input: $input) {
+      ${DRIFT_FIELDS}
+    }
+  }
+`;
+var REMEDIATE_DRIFT = `
+  mutation AdaRemediateDrift($id: ID!) {
+    adaRemediateDrift(id: $id) {
+      ${DRIFT_FIELDS}
+    }
+  }
+`;
+var GET_SYNC_RUN = `
+  query AdaGetSyncRun($id: ID!) {
+    adaSyncRun(id: $id) {
+      ${SYNC_RUN_FIELDS}
+    }
+  }
+`;
+var LIST_SYNC_RUNS = `
+  query AdaListSyncRuns(
+    $connectionId: ID
+    $status: AdaSyncStatus
+    $pagination: PaginationInput
+  ) {
+    adaListSyncRuns(connectionId: $connectionId, status: $status, pagination: $pagination) {
+      items { ${SYNC_RUN_FIELDS} }
+      ${PAGE_INFO_FIELDS}
+    }
+  }
+`;
+var START_SYNC_RUN = `
+  mutation AdaStartSyncRun($input: AdaStartSyncRunInput!) {
+    adaStartSyncRun(input: $input) {
+      ${SYNC_RUN_FIELDS}
+    }
+  }
+`;
+var COMPLETE_SYNC_RUN = `
+  mutation AdaCompleteSyncRun($id: ID!, $input: AdaCompleteSyncRunInput) {
+    adaCompleteSyncRun(id: $id, input: $input) {
+      ${SYNC_RUN_FIELDS}
+    }
+  }
+`;
+var FAIL_SYNC_RUN = `
+  mutation AdaFailSyncRun($id: ID!, $error: String!) {
+    adaFailSyncRun(id: $id, error: $error) {
+      ${SYNC_RUN_FIELDS}
+    }
+  }
+`;
+var CANCEL_SYNC_RUN = `
+  mutation AdaCancelSyncRun($id: ID!) {
+    adaCancelSyncRun(id: $id) {
+      ${SYNC_RUN_FIELDS}
+    }
+  }
+`;
+var LIST_COST_RECORDS = `
+  query AdaListCostRecords($connectionId: ID, $resourceId: ID, $service: String) {
+    adaListCostRecords(connectionId: $connectionId, resourceId: $resourceId, service: $service) {
+      ${COST_RECORD_FIELDS}
+    }
+  }
+`;
+var COST_SUMMARY = `
+  query AdaCostSummary($connectionId: ID) {
+    adaCostSummary(connectionId: $connectionId) {
+      currency
+      total
+      lines { service total }
+    }
+  }
+`;
+var INGEST_COST = `
+  mutation AdaIngestCost($input: AdaIngestCostInput!) {
+    adaIngestCost(input: $input) {
+      ${COST_RECORD_FIELDS}
+    }
+  }
+`;
+var HEALTH = `
+  query AdaHealth {
+    adaHealth
+  }
+`;
+var AdapterKindEnum = zod.z.enum([
+  "CUSTOM",
+  "DATA_SYSTEM",
+  "EDGE",
+  "KUBERNETES",
+  "NETWORK",
+  "ON_PREM",
+  "PRIVATE_CLOUD",
+  "PUBLIC_CLOUD",
+  "SAAS"
+]).describe("Class of infrastructure an adapter integrates");
+var AdapterStatusEnum = zod.z.enum(["ARCHIVED", "DEPRECATED", "DRAFT", "PUBLISHED"]).describe("Lifecycle status of an adapter");
+var AuthMethodEnum = zod.z.enum(["API_KEY", "CERTIFICATE", "IAM_ROLE", "NONE", "OAUTH2", "SERVICE_ACCOUNT"]).describe("Authentication method a connection uses against the target system");
+var ConnectionStatusEnum = zod.z.enum(["CONNECTED", "DEGRADED", "DISABLED", "ERROR", "PENDING"]).describe("Health/lifecycle status of a connection");
+var ResourceStateEnum = zod.z.enum(["DELETED", "DISCOVERED", "DRIFTED", "ORPHANED", "RECONCILED"]).describe("Reconciliation state of a discovered resource");
+var EdgeKindEnum = zod.z.enum(["CONNECTS_TO", "CONTAINS", "DEPENDS_ON", "REPLICATES_TO", "ROUTES_TO"]).describe("Relationship kind of a topology edge between two resources");
+var PolicyKindEnum = zod.z.enum(["COMPLIANCE", "COST", "GUARDRAIL", "NAMING", "SECURITY", "TAGGING"]).describe("Category of a governance policy");
+var PolicyEnforcementEnum = zod.z.enum(["ADVISORY", "BLOCK", "WARN"]).describe("Enforcement mode of a governance policy");
+var SeverityEnum = zod.z.enum(["CRITICAL", "HIGH", "INFO", "LOW", "MEDIUM"]).describe("Severity classification (policies, violations, drift)");
+var ViolationStatusEnum = zod.z.enum(["ACKNOWLEDGED", "OPEN", "RESOLVED", "WAIVED"]).describe("Lifecycle status of a policy violation");
+var DriftStatusEnum = zod.z.enum(["ACKNOWLEDGED", "DETECTED", "IGNORED", "REMEDIATED"]).describe("Lifecycle status of a drift record");
+var SyncKindEnum = zod.z.enum(["COST_INGEST", "DISCOVERY", "FULL", "RECONCILE"]).describe("Kind of sync run against a connection");
+var SyncStatusEnum = zod.z.enum(["CANCELLED", "FAILED", "QUEUED", "RUNNING", "SUCCEEDED"]).describe("Lifecycle status of a sync run");
+var JsonObject = zod.z.record(zod.z.string(), zod.z.unknown());
+var PaginationFields = {
+  limit: zod.z.number().int().optional().describe("Page size (PaginationInput.limit, default 50)"),
+  offset: zod.z.number().int().optional().describe("Pagination offset (PaginationInput.offset, default 0)"),
+  cursor: zod.z.string().optional().describe("Opaque cursor from a previous page (PaginationInput.cursor)")
+};
+function buildPagination(args) {
+  const pagination = {};
+  if (args.limit !== void 0) pagination.limit = args.limit;
+  if (args.offset !== void 0) pagination.offset = args.offset;
+  if (args.cursor !== void 0) pagination.cursor = args.cursor;
+  return Object.keys(pagination).length > 0 ? pagination : void 0;
+}
+
+// src/modules/adaptercloud/tools/adapters.ts
+function registerAdapterTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "adapters_get")),
+    {
+      title: "Get Adapter",
+      description: "Fetch a single AdapterCloud adapter (integration definition) by ID, including its connections.",
+      inputSchema: { id: zod.z.string().describe("Adapter ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_ADAPTER, { id });
+        if (!data.adaAdapter) return errorResult(`Adapter ${id} not found`);
+        return jsonResult(data.adaAdapter);
+      } catch (error) {
+        ctx.logger.error("adaptercloud adapters_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get adapter: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "adapters_list")),
+    {
+      title: "List Adapters",
+      description: "List adapters in the bound workspace with optional kind/status filters and pagination. Returns a page envelope { items, pageInfo }.",
+      inputSchema: {
+        kind: AdapterKindEnum.optional().describe("Filter by infrastructure kind"),
+        status: AdapterStatusEnum.optional().describe("Filter by lifecycle status"),
+        ...PaginationFields
+      }
+    },
+    async ({ kind, status, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_ADAPTERS, {
+          kind,
+          status,
+          pagination: buildPagination({ limit, offset, cursor })
+        });
+        return jsonResult(data.adaListAdapters);
+      } catch (error) {
+        ctx.logger.error("adaptercloud adapters_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list adapters: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "adapters_create")),
+    {
+      title: "Create Adapter",
+      description: "Register a new adapter (integration definition). `slug` must be unique within the workspace. `configSchema` is an optional JSON Schema describing connection config.",
+      inputSchema: {
+        name: zod.z.string().min(1).describe("Adapter display name"),
+        slug: zod.z.string().min(1).describe("URL slug, unique within the workspace"),
+        kind: AdapterKindEnum.optional().describe("Infrastructure kind (default CUSTOM)"),
+        status: AdapterStatusEnum.optional().describe("Initial lifecycle status (default DRAFT)"),
+        vendor: zod.z.string().optional().describe("Vendor / provider name"),
+        version: zod.z.string().optional().describe("Adapter version string"),
+        description: zod.z.string().optional().describe("Adapter description"),
+        capabilities: zod.z.array(zod.z.string()).optional().describe('Capability tags (e.g. "discovery", "cost", "drift")'),
+        configSchema: JsonObject.optional().describe("JSON Schema for connection config"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Free-form tags")
+      }
+    },
+    async ({
+      name,
+      slug,
+      kind,
+      status,
+      vendor,
+      version,
+      description,
+      capabilities,
+      configSchema,
+      tags
+    }) => {
+      try {
+        const input = { name, slug };
+        if (kind !== void 0) input.kind = kind;
+        if (status !== void 0) input.status = status;
+        if (vendor !== void 0) input.vendor = vendor;
+        if (version !== void 0) input.version = version;
+        if (description !== void 0) input.description = description;
+        if (capabilities !== void 0) input.capabilities = capabilities;
+        if (configSchema !== void 0) input.configSchema = configSchema;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_ADAPTER, { input });
+        return jsonResult(data.adaCreateAdapter);
+      } catch (error) {
+        ctx.logger.error("adaptercloud adapters_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create adapter: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "adapters_update")),
+    {
+      title: "Update Adapter",
+      description: "Update an adapter. At least one mutable field must be provided. Use `status` to publish/deprecate an adapter.",
+      inputSchema: {
+        id: zod.z.string().describe("Adapter ID"),
+        name: zod.z.string().optional().describe("Updated display name"),
+        kind: AdapterKindEnum.optional().describe("Updated infrastructure kind"),
+        status: AdapterStatusEnum.optional().describe("Updated lifecycle status"),
+        vendor: zod.z.string().optional().describe("Updated vendor name"),
+        version: zod.z.string().optional().describe("Updated version string"),
+        description: zod.z.string().optional().describe("Updated description"),
+        capabilities: zod.z.array(zod.z.string()).optional().describe("Updated capability tags"),
+        configSchema: JsonObject.optional().describe("Updated connection config JSON Schema"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Updated tags")
+      }
+    },
+    async ({
+      id,
+      name,
+      kind,
+      status,
+      vendor,
+      version,
+      description,
+      capabilities,
+      configSchema,
+      tags
+    }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (kind !== void 0) input.kind = kind;
+        if (status !== void 0) input.status = status;
+        if (vendor !== void 0) input.vendor = vendor;
+        if (version !== void 0) input.version = version;
+        if (description !== void 0) input.description = description;
+        if (capabilities !== void 0) input.capabilities = capabilities;
+        if (configSchema !== void 0) input.configSchema = configSchema;
+        if (tags !== void 0) input.tags = tags;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one of name/kind/status/vendor/version/description/capabilities/configSchema/tags"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_ADAPTER, { id, input });
+        return jsonResult(data.adaUpdateAdapter);
+      } catch (error) {
+        ctx.logger.error("adaptercloud adapters_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update adapter: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "adapters_archive")),
+    {
+      title: "Archive Adapter",
+      description: "Archive (soft-delete) an adapter. Returns true on success.",
+      inputSchema: { id: zod.z.string().describe("Adapter ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          ARCHIVE_ADAPTER,
+          { id }
+        );
+        return jsonResult({ archived: data.adaArchiveAdapter, id });
+      } catch (error) {
+        ctx.logger.error("adaptercloud adapters_archive failed", { error: String(error) });
+        return errorResult(
+          `Failed to archive adapter: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerConnectionTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "connections_get")),
+    {
+      title: "Get Connection",
+      description: "Fetch a single connection by ID, including its adapter and discovered resources.",
+      inputSchema: { id: zod.z.string().describe("Connection ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_CONNECTION, { id });
+        if (!data.adaConnection) return errorResult(`Connection ${id} not found`);
+        return jsonResult(data.adaConnection);
+      } catch (error) {
+        ctx.logger.error("adaptercloud connections_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get connection: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "connections_list")),
+    {
+      title: "List Connections",
+      description: "List connections in the bound workspace with optional adapter/status filters and pagination. Returns a page envelope { items, pageInfo }.",
+      inputSchema: {
+        adapterId: zod.z.string().optional().describe("Filter by adapter ID"),
+        status: ConnectionStatusEnum.optional().describe("Filter by connection status"),
+        ...PaginationFields
+      }
+    },
+    async ({ adapterId, status, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_CONNECTIONS, {
+          adapterId,
+          status,
+          pagination: buildPagination({ limit, offset, cursor })
+        });
+        return jsonResult(data.adaListConnections);
+      } catch (error) {
+        ctx.logger.error("adaptercloud connections_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list connections: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "connections_create")),
+    {
+      title: "Create Connection",
+      description: "Create a connection to a target system for an adapter. `config` holds non-secret connection settings; secrets are referenced by `secretRef`.",
+      inputSchema: {
+        adapterId: zod.z.string().min(1).describe("Adapter this connection uses"),
+        name: zod.z.string().min(1).describe("Connection display name"),
+        authMethod: AuthMethodEnum.optional().describe("Authentication method (default NONE)"),
+        environment: zod.z.string().optional().describe('Environment, e.g. "prod", "staging"'),
+        region: zod.z.string().optional().describe('Target region, e.g. "us-east-1"'),
+        config: JsonObject.optional().describe("Non-secret connection config JSON"),
+        secretRef: zod.z.string().optional().describe("Reference to a stored secret (not the secret)"),
+        targetRef: zod.z.string().optional().describe("Opaque reference to the target system"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Free-form tags")
+      }
+    },
+    async ({
+      adapterId,
+      name,
+      authMethod,
+      environment,
+      region,
+      config,
+      secretRef,
+      targetRef,
+      tags
+    }) => {
+      try {
+        const input = { adapterId, name };
+        if (authMethod !== void 0) input.authMethod = authMethod;
+        if (environment !== void 0) input.environment = environment;
+        if (region !== void 0) input.region = region;
+        if (config !== void 0) input.config = config;
+        if (secretRef !== void 0) input.secretRef = secretRef;
+        if (targetRef !== void 0) input.targetRef = targetRef;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_CONNECTION, { input });
+        return jsonResult(data.adaCreateConnection);
+      } catch (error) {
+        ctx.logger.error("adaptercloud connections_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create connection: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "connections_update")),
+    {
+      title: "Update Connection",
+      description: "Update a connection. At least one mutable field must be provided. To change health/lifecycle status use connections_set_status instead.",
+      inputSchema: {
+        id: zod.z.string().describe("Connection ID"),
+        name: zod.z.string().optional().describe("Updated display name"),
+        authMethod: AuthMethodEnum.optional().describe("Updated authentication method"),
+        environment: zod.z.string().optional().describe("Updated environment"),
+        region: zod.z.string().optional().describe("Updated region"),
+        config: JsonObject.optional().describe("Updated non-secret connection config JSON"),
+        secretRef: zod.z.string().optional().describe("Updated secret reference"),
+        targetRef: zod.z.string().optional().describe("Updated target reference"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Updated tags")
+      }
+    },
+    async ({ id, name, authMethod, environment, region, config, secretRef, targetRef, tags }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (authMethod !== void 0) input.authMethod = authMethod;
+        if (environment !== void 0) input.environment = environment;
+        if (region !== void 0) input.region = region;
+        if (config !== void 0) input.config = config;
+        if (secretRef !== void 0) input.secretRef = secretRef;
+        if (targetRef !== void 0) input.targetRef = targetRef;
+        if (tags !== void 0) input.tags = tags;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one of name/authMethod/environment/region/config/secretRef/targetRef/tags"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_CONNECTION, { id, input });
+        return jsonResult(data.adaUpdateConnection);
+      } catch (error) {
+        ctx.logger.error("adaptercloud connections_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update connection: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "connections_disable")),
+    {
+      title: "Disable Connection",
+      description: "Disable a connection (stops future syncs). Returns the updated connection.",
+      inputSchema: { id: zod.z.string().describe("Connection ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(DISABLE_CONNECTION, { id });
+        return jsonResult(data.adaDisableConnection);
+      } catch (error) {
+        ctx.logger.error("adaptercloud connections_disable failed", { error: String(error) });
+        return errorResult(
+          `Failed to disable connection: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "connections_set_status")),
+    {
+      title: "Set Connection Status",
+      description: "Transition a connection's health/lifecycle status (validated against the connection lifecycle): PENDING, CONNECTED, DEGRADED, ERROR, DISABLED.",
+      inputSchema: {
+        id: zod.z.string().describe("Connection ID"),
+        status: ConnectionStatusEnum.describe("New connection status")
+      }
+    },
+    async ({ id, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(SET_CONNECTION_STATUS, { id, status });
+        return jsonResult(data.adaSetConnectionStatus);
+      } catch (error) {
+        ctx.logger.error("adaptercloud connections_set_status failed", { error: String(error) });
+        return errorResult(
+          `Failed to set connection status: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerResourceTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "resources_get")),
+    {
+      title: "Get Resource",
+      description: "Fetch a single discovered resource by ID, including its connection and dependency edges.",
+      inputSchema: { id: zod.z.string().describe("Resource ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_RESOURCE, { id });
+        if (!data.adaResource) return errorResult(`Resource ${id} not found`);
+        return jsonResult(data.adaResource);
+      } catch (error) {
+        ctx.logger.error("adaptercloud resources_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get resource: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "resources_list")),
+    {
+      title: "List Resources",
+      description: "List discovered resources with optional connection/resourceType/state filters and pagination. Returns a page envelope { items, pageInfo }.",
+      inputSchema: {
+        connectionId: zod.z.string().optional().describe("Filter by connection ID"),
+        resourceType: zod.z.string().optional().describe('Filter by provider resource type, e.g. "aws_instance"'),
+        state: ResourceStateEnum.optional().describe("Filter by reconciliation state"),
+        ...PaginationFields
+      }
+    },
+    async ({ connectionId, resourceType, state, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_RESOURCES, {
+          connectionId,
+          resourceType,
+          state,
+          pagination: buildPagination({ limit, offset, cursor })
+        });
+        return jsonResult(data.adaListResources);
+      } catch (error) {
+        ctx.logger.error("adaptercloud resources_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list resources: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "resources_register")),
+    {
+      title: "Register Resource",
+      description: "Upsert a discovered resource for a connection (idempotent by externalId). Re-registering the same externalId updates the existing resource.",
+      inputSchema: {
+        connectionId: zod.z.string().min(1).describe("Connection the resource was discovered through"),
+        externalId: zod.z.string().min(1).describe("Provider-native unique ID (idempotency key)"),
+        name: zod.z.string().min(1).describe("Resource display name"),
+        resourceType: zod.z.string().min(1).describe('Provider resource type, e.g. "aws_instance"'),
+        region: zod.z.string().optional().describe("Resource region"),
+        monthlyCost: zod.z.number().optional().describe("Estimated monthly cost"),
+        attributes: JsonObject.optional().describe("Provider-native resource attributes JSON"),
+        providerTags: JsonObject.optional().describe("Provider-native tags JSON"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Workspace-side free-form tags")
+      }
+    },
+    async ({
+      connectionId,
+      externalId,
+      name,
+      resourceType,
+      region,
+      monthlyCost,
+      attributes,
+      providerTags,
+      tags
+    }) => {
+      try {
+        const input = { connectionId, externalId, name, resourceType };
+        if (region !== void 0) input.region = region;
+        if (monthlyCost !== void 0) input.monthlyCost = monthlyCost;
+        if (attributes !== void 0) input.attributes = attributes;
+        if (providerTags !== void 0) input.providerTags = providerTags;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(REGISTER_RESOURCE, { input });
+        return jsonResult(data.adaRegisterResource);
+      } catch (error) {
+        ctx.logger.error("adaptercloud resources_register failed", { error: String(error) });
+        return errorResult(
+          `Failed to register resource: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerTopologyTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "topology_list")),
+    {
+      title: "List Topology Edges",
+      description: "List topology edges (resource relationships), optionally filtered by edge kind and/or a resource ID (edges touching that resource).",
+      inputSchema: {
+        kind: EdgeKindEnum.optional().describe("Filter by edge kind"),
+        resourceId: zod.z.string().optional().describe("Filter to edges touching this resource")
+      }
+    },
+    async ({ kind, resourceId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_TOPOLOGY_EDGES, { kind, resourceId });
+        return jsonResult(data.adaListTopologyEdges);
+      } catch (error) {
+        ctx.logger.error("adaptercloud topology_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list topology edges: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "topology_create_edge")),
+    {
+      title: "Create Topology Edge",
+      description: "Create a topology edge between two resources (e.g. DEPENDS_ON, ROUTES_TO, CONTAINS). Set `bidirectional` for symmetric relationships.",
+      inputSchema: {
+        fromResourceId: zod.z.string().min(1).describe("Source resource ID"),
+        toResourceId: zod.z.string().min(1).describe("Target resource ID"),
+        kind: EdgeKindEnum.optional().describe("Edge kind (default DEPENDS_ON)"),
+        weight: zod.z.number().int().optional().describe("Edge weight"),
+        bidirectional: zod.z.boolean().optional().describe("Whether the edge is symmetric (default false)"),
+        attributes: JsonObject.optional().describe("Edge attributes JSON")
+      }
+    },
+    async ({ fromResourceId, toResourceId, kind, weight, bidirectional, attributes }) => {
+      try {
+        const input = { fromResourceId, toResourceId };
+        if (kind !== void 0) input.kind = kind;
+        if (weight !== void 0) input.weight = weight;
+        if (bidirectional !== void 0) input.bidirectional = bidirectional;
+        if (attributes !== void 0) input.attributes = attributes;
+        const data = await ctx.gql.workspace.request(CREATE_TOPOLOGY_EDGE, { input });
+        return jsonResult(data.adaCreateTopologyEdge);
+      } catch (error) {
+        ctx.logger.error("adaptercloud topology_create_edge failed", { error: String(error) });
+        return errorResult(
+          `Failed to create topology edge: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerPolicyTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "policies_get")),
+    {
+      title: "Get Policy",
+      description: "Fetch a single governance policy by ID, including its violations.",
+      inputSchema: { id: zod.z.string().describe("Policy ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_POLICY, { id });
+        if (!data.adaPolicy) return errorResult(`Policy ${id} not found`);
+        return jsonResult(data.adaPolicy);
+      } catch (error) {
+        ctx.logger.error("adaptercloud policies_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get policy: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "policies_list")),
+    {
+      title: "List Policies",
+      description: "List governance policies with optional kind/isActive filters and pagination. Returns a page envelope { items, pageInfo }.",
+      inputSchema: {
+        kind: PolicyKindEnum.optional().describe("Filter by policy kind"),
+        isActive: zod.z.boolean().optional().describe("Filter by active flag"),
+        ...PaginationFields
+      }
+    },
+    async ({ kind, isActive, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_POLICIES, {
+          kind,
+          isActive,
+          pagination: buildPagination({ limit, offset, cursor })
+        });
+        return jsonResult(data.adaListPolicies);
+      } catch (error) {
+        ctx.logger.error("adaptercloud policies_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list policies: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "policies_create")),
+    {
+      title: "Create Policy",
+      description: "Create a governance policy. `expression` is the required policy-rule JSON; `appliesTo` is an optional list of resource-type selectors.",
+      inputSchema: {
+        name: zod.z.string().min(1).describe("Policy name"),
+        expression: JsonObject.describe("Policy-rule expression JSON (required)"),
+        kind: PolicyKindEnum.optional().describe("Policy kind (default GUARDRAIL)"),
+        enforcement: PolicyEnforcementEnum.optional().describe("Enforcement mode (default WARN)"),
+        severity: SeverityEnum.optional().describe("Severity (default MEDIUM)"),
+        description: zod.z.string().optional().describe("Policy description"),
+        appliesTo: zod.z.array(zod.z.string()).optional().describe("Resource-type selectors the policy applies to"),
+        isActive: zod.z.boolean().optional().describe("Whether the policy is active (default true)"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Free-form tags")
+      }
+    },
+    async ({
+      name,
+      expression,
+      kind,
+      enforcement,
+      severity,
+      description,
+      appliesTo,
+      isActive,
+      tags
+    }) => {
+      try {
+        const input = { name, expression };
+        if (kind !== void 0) input.kind = kind;
+        if (enforcement !== void 0) input.enforcement = enforcement;
+        if (severity !== void 0) input.severity = severity;
+        if (description !== void 0) input.description = description;
+        if (appliesTo !== void 0) input.appliesTo = appliesTo;
+        if (isActive !== void 0) input.isActive = isActive;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_POLICY, { input });
+        return jsonResult(data.adaCreatePolicy);
+      } catch (error) {
+        ctx.logger.error("adaptercloud policies_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create policy: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "policies_update")),
+    {
+      title: "Update Policy",
+      description: "Update a governance policy. At least one mutable field must be provided. Use `isActive` to enable/disable a policy.",
+      inputSchema: {
+        id: zod.z.string().describe("Policy ID"),
+        name: zod.z.string().optional().describe("Updated name"),
+        expression: JsonObject.optional().describe("Updated policy-rule expression JSON"),
+        kind: PolicyKindEnum.optional().describe("Updated policy kind"),
+        enforcement: PolicyEnforcementEnum.optional().describe("Updated enforcement mode"),
+        severity: SeverityEnum.optional().describe("Updated severity"),
+        description: zod.z.string().optional().describe("Updated description"),
+        appliesTo: zod.z.array(zod.z.string()).optional().describe("Updated resource-type selectors"),
+        isActive: zod.z.boolean().optional().describe("Updated active flag"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Updated tags")
+      }
+    },
+    async ({
+      id,
+      name,
+      expression,
+      kind,
+      enforcement,
+      severity,
+      description,
+      appliesTo,
+      isActive,
+      tags
+    }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (expression !== void 0) input.expression = expression;
+        if (kind !== void 0) input.kind = kind;
+        if (enforcement !== void 0) input.enforcement = enforcement;
+        if (severity !== void 0) input.severity = severity;
+        if (description !== void 0) input.description = description;
+        if (appliesTo !== void 0) input.appliesTo = appliesTo;
+        if (isActive !== void 0) input.isActive = isActive;
+        if (tags !== void 0) input.tags = tags;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one of name/expression/kind/enforcement/severity/description/appliesTo/isActive/tags"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_POLICY, { id, input });
+        return jsonResult(data.adaUpdatePolicy);
+      } catch (error) {
+        ctx.logger.error("adaptercloud policies_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update policy: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "policies_archive")),
+    {
+      title: "Archive Policy",
+      description: "Archive (soft-delete) a governance policy. Returns true on success.",
+      inputSchema: { id: zod.z.string().describe("Policy ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          ARCHIVE_POLICY,
+          { id }
+        );
+        return jsonResult({ archived: data.adaArchivePolicy, id });
+      } catch (error) {
+        ctx.logger.error("adaptercloud policies_archive failed", { error: String(error) });
+        return errorResult(
+          `Failed to archive policy: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerViolationTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "violations_list")),
+    {
+      title: "List Violations",
+      description: "List policy violations with optional policy/resource/status filters and pagination. Returns a page envelope { items, pageInfo }.",
+      inputSchema: {
+        policyId: zod.z.string().optional().describe("Filter by policy ID"),
+        resourceId: zod.z.string().optional().describe("Filter by resource ID"),
+        status: ViolationStatusEnum.optional().describe("Filter by violation status"),
+        ...PaginationFields
+      }
+    },
+    async ({ policyId, resourceId, status, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_VIOLATIONS, {
+          policyId,
+          resourceId,
+          status,
+          pagination: buildPagination({ limit, offset, cursor })
+        });
+        return jsonResult(data.adaListViolations);
+      } catch (error) {
+        ctx.logger.error("adaptercloud violations_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list violations: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "violations_record")),
+    {
+      title: "Record Violation",
+      description: "Record a policy violation against a resource. `evidence` is optional JSON supporting the finding.",
+      inputSchema: {
+        policyId: zod.z.string().min(1).describe("Violated policy ID"),
+        resourceId: zod.z.string().min(1).describe("Offending resource ID"),
+        message: zod.z.string().min(1).describe("Human-readable violation message"),
+        severity: SeverityEnum.optional().describe(
+          "Severity override (defaults to policy severity)"
+        ),
+        evidence: JsonObject.optional().describe("Supporting evidence JSON")
+      }
+    },
+    async ({ policyId, resourceId, message, severity, evidence }) => {
+      try {
+        const input = { policyId, resourceId, message };
+        if (severity !== void 0) input.severity = severity;
+        if (evidence !== void 0) input.evidence = evidence;
+        const data = await ctx.gql.workspace.request(RECORD_VIOLATION, { input });
+        return jsonResult(data.adaRecordViolation);
+      } catch (error) {
+        ctx.logger.error("adaptercloud violations_record failed", { error: String(error) });
+        return errorResult(
+          `Failed to record violation: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "violations_resolve")),
+    {
+      title: "Resolve Violation",
+      description: "Resolve or waive a violation (validated transition). Waiving (status=WAIVED) requires a `waiverReason`.",
+      inputSchema: {
+        id: zod.z.string().describe("Violation ID"),
+        status: ViolationStatusEnum.describe("New status (e.g. RESOLVED, WAIVED, ACKNOWLEDGED)"),
+        waiverReason: zod.z.string().optional().describe("Reason \u2014 required when status is WAIVED")
+      }
+    },
+    async ({ id, status, waiverReason }) => {
+      try {
+        const data = await ctx.gql.workspace.request(RESOLVE_VIOLATION, { id, status, waiverReason });
+        return jsonResult(data.adaResolveViolation);
+      } catch (error) {
+        ctx.logger.error("adaptercloud violations_resolve failed", { error: String(error) });
+        return errorResult(
+          `Failed to resolve violation: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerDriftTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "drift_list")),
+    {
+      title: "List Drift Records",
+      description: "List configuration-drift records, optionally filtered by resource and/or status. Returns a plain array.",
+      inputSchema: {
+        resourceId: zod.z.string().optional().describe("Filter by resource ID"),
+        status: DriftStatusEnum.optional().describe("Filter by drift status")
+      }
+    },
+    async ({ resourceId, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_DRIFT_RECORDS, { resourceId, status });
+        return jsonResult(data.adaListDriftRecords);
+      } catch (error) {
+        ctx.logger.error("adaptercloud drift_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list drift records: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "drift_record")),
+    {
+      title: "Record Drift",
+      description: "Record a configuration-drift finding for a resource at a given attribute path, capturing expected vs observed values.",
+      inputSchema: {
+        resourceId: zod.z.string().min(1).describe("Drifted resource ID"),
+        attributePath: zod.z.string().min(1).describe('Attribute path that drifted, e.g. "tags.env"'),
+        expectedValue: JsonObject.optional().describe("Expected value JSON"),
+        observedValue: JsonObject.optional().describe("Observed value JSON"),
+        severity: SeverityEnum.optional().describe("Severity of the drift")
+      }
+    },
+    async ({ resourceId, attributePath, expectedValue, observedValue, severity }) => {
+      try {
+        const input = { resourceId, attributePath };
+        if (expectedValue !== void 0) input.expectedValue = expectedValue;
+        if (observedValue !== void 0) input.observedValue = observedValue;
+        if (severity !== void 0) input.severity = severity;
+        const data = await ctx.gql.workspace.request(RECORD_DRIFT, { input });
+        return jsonResult(data.adaRecordDrift);
+      } catch (error) {
+        ctx.logger.error("adaptercloud drift_record failed", { error: String(error) });
+        return errorResult(
+          `Failed to record drift: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "drift_remediate")),
+    {
+      title: "Remediate Drift",
+      description: "Mark a drift record as remediated. Returns the updated drift record.",
+      inputSchema: { id: zod.z.string().describe("Drift record ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(REMEDIATE_DRIFT, { id });
+        return jsonResult(data.adaRemediateDrift);
+      } catch (error) {
+        ctx.logger.error("adaptercloud drift_remediate failed", { error: String(error) });
+        return errorResult(
+          `Failed to remediate drift: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerSyncTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sync_get")),
+    {
+      title: "Get Sync Run",
+      description: "Fetch a single sync run by ID, including its counts and summary.",
+      inputSchema: { id: zod.z.string().describe("Sync run ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_SYNC_RUN, { id });
+        if (!data.adaSyncRun) return errorResult(`Sync run ${id} not found`);
+        return jsonResult(data.adaSyncRun);
+      } catch (error) {
+        ctx.logger.error("adaptercloud sync_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get sync run: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sync_list")),
+    {
+      title: "List Sync Runs",
+      description: "List sync runs with optional connection/status filters and pagination. Returns a page envelope { items, pageInfo }.",
+      inputSchema: {
+        connectionId: zod.z.string().optional().describe("Filter by connection ID"),
+        status: SyncStatusEnum.optional().describe("Filter by sync status"),
+        ...PaginationFields
+      }
+    },
+    async ({ connectionId, status, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_SYNC_RUNS, {
+          connectionId,
+          status,
+          pagination: buildPagination({ limit, offset, cursor })
+        });
+        return jsonResult(data.adaListSyncRuns);
+      } catch (error) {
+        ctx.logger.error("adaptercloud sync_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list sync runs: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sync_start")),
+    {
+      title: "Start Sync Run",
+      description: "Start a sync run against a connection. `kind` selects DISCOVERY (default), RECONCILE, FULL, or COST_INGEST.",
+      inputSchema: {
+        connectionId: zod.z.string().min(1).describe("Connection to sync"),
+        kind: SyncKindEnum.optional().describe("Sync kind (default DISCOVERY)")
+      }
+    },
+    async ({ connectionId, kind }) => {
+      try {
+        const input = { connectionId };
+        if (kind !== void 0) input.kind = kind;
+        const data = await ctx.gql.workspace.request(START_SYNC_RUN, { input });
+        return jsonResult(data.adaStartSyncRun);
+      } catch (error) {
+        ctx.logger.error("adaptercloud sync_start failed", { error: String(error) });
+        return errorResult(
+          `Failed to start sync run: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sync_complete")),
+    {
+      title: "Complete Sync Run",
+      description: "Mark a sync run as succeeded, recording its discovered/reconciled/drift/violation counts and a summary.",
+      inputSchema: {
+        id: zod.z.string().describe("Sync run ID"),
+        discoveredCount: zod.z.number().int().optional().describe("Number of resources discovered"),
+        reconciledCount: zod.z.number().int().optional().describe("Number of resources reconciled"),
+        driftCount: zod.z.number().int().optional().describe("Number of drift records detected"),
+        violationCount: zod.z.number().int().optional().describe("Number of violations detected"),
+        summary: JsonObject.optional().describe("Run summary JSON")
+      }
+    },
+    async ({ id, discoveredCount, reconciledCount, driftCount, violationCount, summary }) => {
+      try {
+        const input = {};
+        if (discoveredCount !== void 0) input.discoveredCount = discoveredCount;
+        if (reconciledCount !== void 0) input.reconciledCount = reconciledCount;
+        if (driftCount !== void 0) input.driftCount = driftCount;
+        if (violationCount !== void 0) input.violationCount = violationCount;
+        if (summary !== void 0) input.summary = summary;
+        const data = await ctx.gql.workspace.request(COMPLETE_SYNC_RUN, {
+          id,
+          input: Object.keys(input).length > 0 ? input : void 0
+        });
+        return jsonResult(data.adaCompleteSyncRun);
+      } catch (error) {
+        ctx.logger.error("adaptercloud sync_complete failed", { error: String(error) });
+        return errorResult(
+          `Failed to complete sync run: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sync_fail")),
+    {
+      title: "Fail Sync Run",
+      description: "Mark a sync run as failed with an error message.",
+      inputSchema: {
+        id: zod.z.string().describe("Sync run ID"),
+        error: zod.z.string().min(1).describe("Failure reason / error message")
+      }
+    },
+    async ({ id, error }) => {
+      try {
+        const data = await ctx.gql.workspace.request(FAIL_SYNC_RUN, { id, error });
+        return jsonResult(data.adaFailSyncRun);
+      } catch (err) {
+        ctx.logger.error("adaptercloud sync_fail failed", { error: String(err) });
+        return errorResult(
+          `Failed to fail sync run: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sync_cancel")),
+    {
+      title: "Cancel Sync Run",
+      description: "Cancel an in-flight or queued sync run. Returns the updated sync run.",
+      inputSchema: { id: zod.z.string().describe("Sync run ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(CANCEL_SYNC_RUN, { id });
+        return jsonResult(data.adaCancelSyncRun);
+      } catch (error) {
+        ctx.logger.error("adaptercloud sync_cancel failed", { error: String(error) });
+        return errorResult(
+          `Failed to cancel sync run: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerCostTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "cost_list")),
+    {
+      title: "List Cost Records",
+      description: "List cost records, optionally filtered by connection, resource, and/or service. Returns a plain array.",
+      inputSchema: {
+        connectionId: zod.z.string().optional().describe("Filter by connection ID"),
+        resourceId: zod.z.string().optional().describe("Filter by resource ID"),
+        service: zod.z.string().optional().describe('Filter by cost service, e.g. "EC2"')
+      }
+    },
+    async ({ connectionId, resourceId, service }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_COST_RECORDS, { connectionId, resourceId, service });
+        return jsonResult(data.adaListCostRecords);
+      } catch (error) {
+        ctx.logger.error("adaptercloud cost_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list cost records: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "cost_summary")),
+    {
+      title: "Cost Summary",
+      description: "Aggregate spend grouped by cost service across the workspace, optionally scoped to a single connection.",
+      inputSchema: {
+        connectionId: zod.z.string().optional().describe("Scope the summary to one connection")
+      }
+    },
+    async ({ connectionId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(COST_SUMMARY, { connectionId });
+        return jsonResult(data.adaCostSummary);
+      } catch (error) {
+        ctx.logger.error("adaptercloud cost_summary failed", { error: String(error) });
+        return errorResult(
+          `Failed to get cost summary: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "cost_ingest")),
+    {
+      title: "Ingest Cost Record",
+      description: "Ingest a cost record for a service over a billing period. `breakdown` is optional per-line-item JSON.",
+      inputSchema: {
+        service: zod.z.string().min(1).describe('Cost service, e.g. "EC2"'),
+        amount: zod.z.number().describe("Cost amount"),
+        periodStart: zod.z.string().min(1).describe("Billing period start (ISO 8601 DateTime)"),
+        periodEnd: zod.z.string().min(1).describe("Billing period end (ISO 8601 DateTime)"),
+        currency: zod.z.string().optional().describe('Currency code, e.g. "USD"'),
+        connectionId: zod.z.string().optional().describe("Owning connection ID"),
+        resourceId: zod.z.string().optional().describe("Owning resource ID"),
+        breakdown: JsonObject.optional().describe("Per-line-item cost breakdown JSON")
+      }
+    },
+    async ({
+      service,
+      amount,
+      periodStart,
+      periodEnd,
+      currency,
+      connectionId,
+      resourceId,
+      breakdown
+    }) => {
+      try {
+        const input = { service, amount, periodStart, periodEnd };
+        if (currency !== void 0) input.currency = currency;
+        if (connectionId !== void 0) input.connectionId = connectionId;
+        if (resourceId !== void 0) input.resourceId = resourceId;
+        if (breakdown !== void 0) input.breakdown = breakdown;
+        const data = await ctx.gql.workspace.request(INGEST_COST, { input });
+        return jsonResult(data.adaIngestCost);
+      } catch (error) {
+        ctx.logger.error("adaptercloud cost_ingest failed", { error: String(error) });
+        return errorResult(
+          `Failed to ingest cost record: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/adaptercloud/tools/health.ts
+function registerHealthTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "health")),
+    {
+      title: "AdapterCloud Health Check",
+      description: "Public health probe for the AdapterCloud subgraph (adaHealth). Requires no authentication.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await ctx.gql.workspace.request(HEALTH, {});
+        return jsonResult({ ok: true, status: data.adaHealth });
+      } catch (error) {
+        ctx.logger.error("adaptercloud health failed", { error: String(error) });
+        return errorResult(
+          `AdapterCloud health check failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/adaptercloud/resources.ts
+function registerAdaptercloudResources(server, ctx, track) {
+  const schemaUri = track(mcpResourceUri(ctx.productName, "schema"));
+  const adaptersUri = track(mcpResourceUri(ctx.productName, "adapters"));
+  const connectionsUri = track(mcpResourceUri(ctx.productName, "connections"));
+  const costUri = track(mcpResourceUri(ctx.productName, "cost"));
+  server.registerResource(
+    "adaptercloud-schema",
+    schemaUri,
+    {
+      title: "AdapterCloud Domain Schema",
+      description: "Overview of the AdapterCloud (InfraVerse) domain \u2014 entities, enums, and the per-entity tool surface.",
+      mimeType: "text/plain"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${schemaUri} requested`);
+      const schema = `# AdapterCloud Domain (Overview)
+
+InfraVerse \u2014 the digital-infrastructure continuum. Stitches fragmented
+infrastructure (multi-cloud, on-prem, edge, SaaS) into one continuous,
+governable fabric.
+
+## Entities
+- AdaAdapter \u2014 an integration definition (the adapter catalog)
+- AdaConnection \u2014 a live connection to a target system for an adapter
+- AdaResource \u2014 a discovered infrastructure resource (upserted by externalId)
+- AdaTopologyEdge \u2014 a dependency/relationship edge between two resources
+- AdaPolicy \u2014 a governance guardrail (with violations)
+- AdaPolicyViolation \u2014 a policy violation against a resource
+- AdaDriftRecord \u2014 a configuration-drift finding against a resource
+- AdaSyncRun \u2014 a discovery/reconcile/cost-ingest run against a connection
+- AdaCostRecord \u2014 a cost record for a service over a billing period
+
+## Enums
+- AdaAdapterKind: CUSTOM, DATA_SYSTEM, EDGE, KUBERNETES, NETWORK, ON_PREM, PRIVATE_CLOUD, PUBLIC_CLOUD, SAAS
+- AdaAdapterStatus: ARCHIVED, DEPRECATED, DRAFT, PUBLISHED
+- AdaAuthMethod: API_KEY, CERTIFICATE, IAM_ROLE, NONE, OAUTH2, SERVICE_ACCOUNT
+- AdaConnectionStatus: CONNECTED, DEGRADED, DISABLED, ERROR, PENDING
+- AdaResourceState: DELETED, DISCOVERED, DRIFTED, ORPHANED, RECONCILED
+- AdaEdgeKind: CONNECTS_TO, CONTAINS, DEPENDS_ON, REPLICATES_TO, ROUTES_TO
+- AdaPolicyKind: COMPLIANCE, COST, GUARDRAIL, NAMING, SECURITY, TAGGING
+- AdaPolicyEnforcement: ADVISORY, BLOCK, WARN
+- AdaSeverity: CRITICAL, HIGH, INFO, LOW, MEDIUM
+- AdaViolationStatus: ACKNOWLEDGED, OPEN, RESOLVED, WAIVED
+- AdaDriftStatus: ACKNOWLEDGED, DETECTED, IGNORED, REMEDIATED
+- AdaSyncKind: COST_INGEST, DISCOVERY, FULL, RECONCILE
+- AdaSyncStatus: CANCELLED, FAILED, QUEUED, RUNNING, SUCCEEDED
+
+## Tool groups
+adapters, connections, resources, topology (fabric); policies, violations, drift
+(governance); sync, cost (operations/FinOps); plus the public health probe.
+All run against the WORKSPACE gateway (workspace-scoped) except the public
+health probe.
+`;
+      return {
+        contents: [{ uri: schemaUri, text: schema, mimeType: "text/plain" }]
+      };
+    }
+  );
+  server.registerResource(
+    "adaptercloud-adapters",
+    adaptersUri,
+    {
+      title: "AdapterCloud Adapter Catalog",
+      description: "The first 50 adapters (integration definitions) in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${adaptersUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(LIST_ADAPTERS, {
+          pagination: { limit: 50, offset: 0 }
+        });
+        return {
+          contents: [
+            {
+              uri: adaptersUri,
+              text: JSON.stringify(data.adaListAdapters, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: adaptersUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "adaptercloud-connections",
+    connectionsUri,
+    {
+      title: "AdapterCloud Connection Directory",
+      description: "The first 50 connections in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${connectionsUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(
+          LIST_CONNECTIONS,
+          { pagination: { limit: 50, offset: 0 } }
+        );
+        return {
+          contents: [
+            {
+              uri: connectionsUri,
+              text: JSON.stringify(data.adaListConnections, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: connectionsUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "adaptercloud-cost",
+    costUri,
+    {
+      title: "AdapterCloud Cost Summary",
+      description: "Aggregate workspace spend grouped by cost service (FinOps headline).",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${costUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(COST_SUMMARY, {});
+        return {
+          contents: [
+            {
+              uri: costUri,
+              text: JSON.stringify(data.adaCostSummary, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: costUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+function registerAdaptercloudPrompts(server, ctx, track) {
+  const p = ctx.productName;
+  const onboardingName = track(mcpPromptName(p, "connection-onboarding"));
+  const governanceName = track(mcpPromptName(p, "governance-sweep"));
+  server.registerPrompt(
+    onboardingName,
+    {
+      title: "Connection Onboarding",
+      description: "Guide for connecting a new target system end to end: register an adapter, create a connection, run discovery, and review the discovered resources.",
+      argsSchema: {
+        adapterName: zod.z.string().optional().describe("Adapter / integration name"),
+        kind: zod.z.string().optional().describe("Infrastructure kind (AdaAdapterKind)")
+      }
+    },
+    ({ adapterName, kind }) => {
+      ctx.logger.debug(`Prompt ${onboardingName} called`, { adapterName, kind });
+      const nameNote = adapterName ? `Use the adapter name "${adapterName}".` : "Ask the user for the adapter / integration name.";
+      const kindNote = kind ? `Use kind ${kind}.` : "Help the user pick an AdaAdapterKind.";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Help me connect a new target system to AdapterCloud.
+
+1. **Register Adapter**: Use ${p}_adapters_create. ${nameNote} ${kindNote} Provide a unique slug; optionally a configSchema and capabilities.
+2. **Publish Adapter**: Use ${p}_adapters_update with status=PUBLISHED when the definition is ready.
+3. **Create Connection**: Use ${p}_connections_create with the new adapterId, an authMethod, environment/region, and a secretRef (never inline secrets).
+4. **Run Discovery**: Use ${p}_sync_start with the connectionId and kind=DISCOVERY, then poll ${p}_sync_get until status=SUCCEEDED.
+5. **Review Resources**: Use ${p}_resources_list filtered by the new connectionId; inspect state and monthlyCost.
+6. **Map Topology (optional)**: Use ${p}_topology_create_edge to record dependencies between discovered resources.
+
+Show results at each step and confirm before running discovery.`
+            }
+          }
+        ]
+      };
+    }
+  );
+  server.registerPrompt(
+    governanceName,
+    {
+      title: "Governance Sweep",
+      description: "Governance + FinOps review workflow: check connection health, triage drift and open violations, resolve/waive them, and review spend.",
+      argsSchema: {
+        connectionId: zod.z.string().optional().describe("Connection ID to scope the sweep")
+      }
+    },
+    ({ connectionId }) => {
+      ctx.logger.debug(`Prompt ${governanceName} called`, { connectionId });
+      const scopeNote = connectionId ? `Scope the sweep to connection "${connectionId}".` : `First list connections with ${p}_connections_list and pick one (or sweep the whole workspace).`;
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Run an AdapterCloud governance + FinOps sweep. ${scopeNote}
+
+1. **Connection Health**: Use ${p}_connections_list and flag any DEGRADED / ERROR connections.
+2. **Drift**: Use ${p}_drift_list filtered by status=DETECTED. For each remediated item use ${p}_drift_remediate.
+3. **Violations**: Use ${p}_violations_list filtered by status=OPEN. Resolve each with ${p}_violations_resolve (status=RESOLVED, or WAIVED with a waiverReason).
+4. **Policies**: Use ${p}_policies_list to confirm the active guardrails; tighten enforcement with ${p}_policies_update if needed.
+5. **Cost**: Use ${p}_cost_summary for headline spend by service, then ${p}_cost_list to drill into a specific service.
+
+Summarize what needs attention after each step.`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/modules/adaptercloud/index.ts
+var adaptercloudModule = {
+  id: "adaptercloud",
+  version: "0.0.1",
+  displayName: "AdapterCloud",
+  dependsOn: ["auth"],
+  capabilities: { tools: {}, resources: {}, prompts: {} },
+  register(server, ctx) {
+    const tools = [];
+    const resources = [];
+    const prompts = [];
+    const trackTool = (n) => {
+      tools.push(n);
+      return n;
+    };
+    const trackResource = (uri) => {
+      resources.push(uri);
+      return uri;
+    };
+    const trackPrompt = (n) => {
+      prompts.push(n);
+      return n;
+    };
+    registerAdapterTools(server, ctx, trackTool);
+    registerConnectionTools(server, ctx, trackTool);
+    registerResourceTools(server, ctx, trackTool);
+    registerTopologyTools(server, ctx, trackTool);
+    registerPolicyTools(server, ctx, trackTool);
+    registerViolationTools(server, ctx, trackTool);
+    registerDriftTools(server, ctx, trackTool);
+    registerSyncTools(server, ctx, trackTool);
+    registerCostTools(server, ctx, trackTool);
+    registerHealthTools(server, ctx, trackTool);
+    registerAdaptercloudResources(server, ctx, trackResource);
+    registerAdaptercloudPrompts(server, ctx, trackPrompt);
+    return { tools, resources, prompts };
+  }
+};
+var adaptercloud_default = adaptercloudModule;
+
+module.exports = adaptercloud_default;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map